Tujuan: mempelajari \(f_\theta(x)\) yang meminimumkan fungsi kerugian pada data latih (mis. log-loss untuk probabilitas kelas, atau proxy seperti error rate / 1 - akurasi) dan generalisasi baik pada data baru.
Catatan: akurasi saja bisa menyesatkan pada kelas tidak seimbang — gunakan juga precision/recall, F1, atau AUC-ROC (kasus biner).
Klasifikasi — bahasa awam
Klasifikasi artinya komputer membantu menjawab: “objek ini masuk kelompok mana?” — misalnya email spam atau bukan, transaksi curang atau normal, tanaman varietas A, B, atau C. Inputnya berupa angka-angka ciri (fitur); outputnya label diskret (nama kelas).
Bedanya dengan regresi (materi sebelumnya): jawaban yang diinginkan berupa kategori, bukan bilangan kontinu seperti harga atau suhu.
Persiapan pemodelan: tentukan skenario dulu
Sebelum memilih algoritme, jernihkan:
Elemen
Pertanyaan panduan
Tujuan bisnis
Prediksi dini gagal mesin? penipuan? prioritas false positive vs false negative?
Target \(y\)
Label apa yang tersedia? apakah perlu agregasi waktu / entitas?
Fitur \(X\)
Apa yang diizinkan saat inferensi (tanpa kebocoran)? format missing?
Metrik
Akurasi cukup? atau F1-macro, balanced accuracy, cost-sensitive?
Baseline
Prediksi mayoritas kelas / aturan sederhana — untuk menilai apakah model ML layak.
Deliverable awal: satu dokumen ringkas (setengah halaman) yang mengunci definisi \(y\) dan metrik utama.
Pembagian data: latih vs uji
Set latih (training): dipakai untuk mempelajari parameter model (dan sering hiperparameter via validasi silang).
Set uji (testing):hanya untuk estimasi performa final — tidak dipakai untuk menyesuaikan hiperparameter (kecuali dalam protokol nested CV).
Praktik umum:train_test_split(..., test_size=0.2–0.3, random_state=...) agar hasil reproduksibel.
Untuk klasifikasi dengan kelas tidak seimbang, gunakan stratify=y agar proporsi kelas di train/test mirip.
Latih vs uji — analogi awam
Set latih ibarat buku latihan soal: di sinilah model “berlatih” mencari pola. Set uji ibarat ujian resmi dengan soal yang sengaja tidak dipakai saat latihan — supaya kita tahu apakah pola yang dipelajari benar-benar berguna di situasi baru.
Kalau kita sengaja melihat jawaban ujian saat latihan (misalnya menghitung rata-rata fitur dari train + test sekaligus lalu memakainya untuk normalisasi), nilai ujian bisa terlihat bagus padahal menipu — itulah inti kebocoran data yang harus dihindari.
Demo: Wine — bentuk data & pembagian
import pandas as pdfrom sklearn.datasets import load_winefrom sklearn.model_selection import train_test_splitwine = load_wine(as_frame=True)X = wine.datay = wine.targetX_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.25, stratify=y, random_state=42)print("Fitur:", list(X.columns[:5]), "...")print("Bentuk X_train / X_test:", X_train.shape, X_test.shape)print("Distribusi kelas (train):\n", y_train.value_counts().sort_index())print("Distribusi kelas (test):\n", y_test.value_counts().sort_index())print("\nContoh baris X_train:\n", X_train.head(3).to_string())
Dataset Wine: 13 fitur kimia, 3 kelas kultivar — cocok untuk membandingkan beberapa klasifikator pada ruang fitur berdimensi sedang.
Kebocoran = informasi dari set uji (atau masa depan) “masuk” ke proses latih, sehingga skor test terlalu optimis.
Contoh
Mengapa berbahaya
Standarisasi fit pada train+test sekaligus
Statistik test memengaruhi transformasi
Fitur yang hanya tersedia setelah kejadian target
Model “tahu jawaban”
Duplikat baris antara train dan test
Uji tidak independen
Aturan emas: semua yang membutuhkan estimasi dari data (rata-rata, kategori langka, imputasi) → fit pada train, transform pada test — idealnya dalam Pipeline.
Validasi silang (k-fold) singkat
Untuk memilih \(k\) pada k-NN atau depth pohon, jangan memakai skor test berulang kali.
K-fold CV: data latih dibagi \(k\) lipatan; model dilatih di \(k-1\) lipatan, divalidasi di lipatan tersisa; diulang \(k\) kali → rata-rata metrik validasi.
Nested CV: lipatan luar untuk estimasi performa, lipatan dalam untuk tuning — dipakai jika anggaran komputasi memungkinkan.
Validasi silang — bahasa awam
Bayangkan Anda punya 5 set latihan bergantian: setiap kali Anda menyembunyikan satu set sebagai “ujian mini”, berlatih dengan 4 set lain, lalu cek skor di set yang disembunyikan. Diulang 5 kali lalu dirata-rata — itulah gambaran k-fold: estimasi seberapa bagus model di data yang belum dilihat dalam latihan, tanpa memakai set uji besar yang harusnya suci.
k-NN — bahasa awam
k-NN seperti bertanya ke tetangga terdekat di kompleks perumahan: “blok ini termasuk zona hijau atau biru?” Anda melihat k rumah paling dekat; jika kebanyakan tetangga zona hijau, Anda menjawab hijau. Tidak ada “rumus panjang” yang disimpan — yang disimpan hanya daftar rumah lama beserta labelnya; saat ada rumah baru, kita mengukur jarak ke semua (atau banyak) rumah lalu m voting.
Karena itu algoritme ini terasa sederhana, tetapi bisa lambat jika data sangat besar, dan sensitif terhadap satuan (misalnya harga dalam juta vs luas dalam m²) — seperti membandingkan jarak “rumah A” ke “rumah B” kalau satu sumbu pakai skala yang tidak adil.
Grafik: pengaruh \(k\) pada batas keputusan (data sintetis)
Data dua bulan sabit (make_moons): \(k\) kecil → batas berlekuk mengikuti titik; \(k\) besar → batas lebih halus (suara mayoritas atas wilayah lebih luas).
Grafik: pengaruh \(k\) pada batas keputusan (data sintetis)
K-Nearest Neighbors (k-NN) — definisi
k-NN (k-Nearest Neighbors) adalah klasifikator berbasis contoh (instance-based): ia tidak memperkirakan parameter global seperti bobot regresi; ia menyimpan data latih \(\{(x_i, y_i)\}_{i=1}^n\) dan, saat ada titik uji \(x\), mencari \(k\) titik latih yang paling dekat menurut suatu jarak di \(\mathbb{R}^p\).
Aturan prediksi (klasifikasi): misalkan indeks tetangga terdekat adalah \(\mathcal{N}_k(x)\). Prediksi sering berupa suara mayoritas:
Dengan pembobotan jarak (weights='distance' di sklearn), suara titik \(i\) diperbesar sebanding \(1/d(x,x_i)\) sehingga tetangga sangat dekat lebih berpengaruh.
k-NN: “latih” vs inferensi
Fase latih (training): secara konseptual hanya menyimpan matriks fitur dan label — kompleksitas penyimpanan \(O(np)\).
Fase prediksi: untuk satu \(x\), perlu menghitung jarak ke (setidaknya) seluruh titik latih → \(O(np)\) per prediksi naif; struktur data seperti k-d tree atau ball tree dapat mempercepat di dimensi tidak terlalu tinggi.
Karena itu k-NN cocok untuk dataset tidak terlalu besar; untuk skala besar sering dipakai approximate nearest neighbors (kuliah lanjutan) atau model parametrik lain.
Metrik jarak yang umum
Untuk dua titik \(a, b \in \mathbb{R}^p\):
Euclidean (default di sklearn):\(d(a,b) = \bigl(\sum_{j=1}^p (a_j-b_j)^2\bigr)^{1/2}\)
Parameter p di KNeighborsClassifier(metric='minkowski', p=...) mengatur eksponen tersebut.
Fitur kategorik tidak langsung masuk jarak Euclidean — perlu encoding (one-hot, ordinal hati-hati) atau metrik campuran.
Peran \(k\) dalam bias–variansi (intuisi)
\(k\) kecil (mis. 1): setiap prediksi mengikuti satu tetangga terdekat → batas keputusan sangat berlekuk; akurasi latih sering sangat tinggi (bahan hingga sempurna) tetapi prediksi tidak stabil terhadap noise dan variasi sampel (varians tinggi).
\(k\) besar: prediksi dirata-ratakan atas banyak tetangga → permukaan keputusan lebih halus → bias naik, varians turun — mirip efek regularisasi; jika \(k \to n\), prediksi mendekati kelas mayoritas global.
Pemilihan \(k\) sebaiknya memakai validasi silang pada set latih, bukan mengutak-atik skor set uji.
Mengapa k-NN sensitif terhadap skala?
Fitur dengan rentang besar (mis. massa gram) mendominasi jarak dibanding fitur kecil (mis. rasio 0–1).
Solusi:StandardScaler atau MinMaxScaler di dalam Pipeline sebelum KNeighborsClassifier.
Grafik: mengapa penskalaan penting untuk k-NN?
Dua kelas dipisahkan sejajar sumbu horizontal (fitur kiri informatif, skala kecil). Sumbu vertikal hanya noise dengan rentang besar. Tanpa penskalaan, jarak Euclidean didominasi sumbu vertikal → batas salah; dengan StandardScaler, kedua sumbu setara → batas mengikuti pemisah sebenarnya.
Pohon keputusan seperti alur kerja di meja layanan: “Apakah usia di atas 60? Jika ya, cek tekanan darah; jika tidak, cek gejala lain…” Setiap pertanyaan memecah antrian menjadi dua (atau lebih) kelompok sampai tiba di kesimpulan (daun): “prioritas tinggi / rendah”. Keuntungannya: aturan mudah dibaca manusia dan diaudit (“mengapa kasus ini masuk cabang kiri?”).
Kelemahan: jika pertanyaan terlalu banyak dan terlalu detail mengikuti noise data latih, aturan itu bagus di latihan tetapi kaku di ujian — seperti menghafal contoh soal tanpa prinsip.
Decision Tree — apa yang dimodelkan?
Pohon keputusan mempartisi ruang fitur \(\mathbb{R}^p\) menjadi kumpulan region (biasanya kotak sumbu-sejajar / axis-aligned): di setiap region, prediksi adalah konstan (klasifikasi: kelas mayoritas di daun; regresi: rata-rata target).
Secara formal, model adalah fungsi piecewise constant:
dengan \(\{R_m\}\) disjoint region yang dibangun oleh rangkaian split jika \(x_j \leq t\) vs lainnya.
Kelebihan: aturan if–else mudah diaudit; menangkap nonlinearitas dan interaksi antar fitur tanpa mendefinisikan basis manual.
Kelemahan: pohon dalam saja varians tinggi (sensitif terhadap variasi sampel dan noise); sedikit perubahan data bisa mengubah struktur pohon.
Bagaimana split dipilih? (greedy, binary)
Algoritme CART (Classification and Regression Trees) membangun pohon rekursif: pada setiap simpul, cari pasangan (fitur \(j\), ambang \(t\)) yang meminimumkan impurity gabungan anak kiri/kanan.
Impurity umum untuk klasifikasi:
Gini:\(G = \sum_{c=1}^{C} \hat{p}_c(1-\hat{p}_c)\) — probabilitas \(\hat{p}_c\) dihitung dari proporsi kelas di simpul.
Random Forest seperti rapat komite dengan banyak anggota, masing-masing hanya melihat sebagian data dan sebagian pertanyaan (subsample baris + subset fitur acak), lalu masing-masing membuat pohon keputusan kecil. Saat ada kasus baru, setiap pohon memberi suara; suara terbanyak menang.
Dengan banyak “pendapat” yang sedikit berbeda, kesalahan satu pohon yang terlalu menyesuaikan noise akan tertimbun oleh pohon lain — jadi sering lebih stabil dan akurat daripada satu pohon raksasa. Harganya: sulit menjelaskan ke pemangku kepentingan satu alur if–else tunggal; kita lebih sering memakai pentingnya fitur atau alat interpretasi lain.
Random Forest
Ide: latih banyak pohon pada bootstrap sample baris latih; pada setiap split, pertimbangkan subset acak fitur (random subspace).
Prediksi:suara mayoritas (klasifikasi) atau rata-rata (regresi) antar pohon.
Manfaat:mengurangi varians dibanding satu pohon dalam; sering akurat tanpa banyak tuning.
Trade-off: kurang transparan daripada satu pohon (interpretasi via importance fitur, SHAP di kuliah lanjutan).
Grafik: satu pohon vs Random Forest (batas keputusan)
Satu pohon bisa tidak stabil pada batas; hutan meratakan variasi lewat suara banyak pohon — batas cenderung lebih mulus pada contoh ini.
SVM (versi intuitif) mencari garis atau permukaan pemisah antara dua kelompok titik yang sejauh mungkin dari titik latih terdekat di kedua sisi — seperti memasang pembatas jalan di tengah yang memberi ruang aman (margin) supaya sedikit gangguan pada posisi titik tidak langsung mengubah sisi klasifikasi. Titik-titik yang “menempel” di pembatas inilah yang disebut support vectors.
Kalau dua kelompok tidak bisa dipisah garis lurus, kita bisa memakai kernel (mis. RBF): bayangan intuitifnya, data dianggap diletakkan di ruang lebih tinggi sehingga kelompok yang tumpang tindih bisa terpisah permukaan yang lebih fleksibel — mirip menggulung kertas 2D sehingga titik yang tadinya campur jadi terpisah di 3D.
Grafik: SVM linear vs kernel RBF (data tidak linear)
Kernel linear mencoba garis lurus; RBF memungkinkan batas melengkung mengelilingi kelompok — cocok untuk pola bulan sabit.
Grafik: SVM linear vs kernel RBF (data tidak linear)
Support Vector Machine (SVM) — ide geometris
Untuk data terpisah linear (dua kelas), SVM mencari hyperplane\(\{x : w^\top x + b = 0\}\) yang:
memisahkan kelas (sisi berlawanan untuk titik positif/negatif), dan
memaksimalkan margin — jarak terpendek dari hyperplane ke titik latih terdekat.
Margin geometris sebanding dengan \(1/\|w\|\); memaksimalkan margin setara (dengan normalisasi tertentu) dengan meminimumkan \(\frac{1}{2}\|w\|^2\) di bawah kendala pemisahan — solusi bergantung hanya pada subset titik di batas → support vectors.
Soft margin & peran hiperparameter \(C\)
Data nyata sering tidak sepenuhnya terpisah linear. Soft-margin SVM memperkenalkan variabel slack\(\xi_i \geq 0\) agar beberapa titik boleh melanggar margin kecil:
\(C\) besar: penalti kuat pada pelanggaran → margin sempit, model mengikuti data latih lebih ketat (risiko overfit relatif naik).
\(C\) kecil: toleransi pelanggaran lebih besar → margin lebar, decision boundary lebih halus / lebih “regularized”.
Dualitas & kernel trick (mengapa SVM “nonlinear”)
Formulasi dual menyatakan solusi \(w\) sebagai kombinasi linear titik latih\(w = \sum_i \alpha_i y_i x_i\) dengan \(\alpha_i \geq 0\) (hanya titik dengan \(\alpha_i>0\) yang menjadi support vectors).
Prediksi memakai bentuk yang hanya membutuhkan inner product\(x_i^\top x_j\) — mengganti inner product dengan fungsi kernel positif-definit \(K(x_i,x_j)\) setara dengan bekerja di ruang fitur berdimensi tinggi tanpa menghitung pemetaan eksplisit \(\phi(x)\).
Kernel linear\(K(x,x') = x^\top x'\) memulihkan pemisah hyperplane asli; kernel polinomial dan RBF memperkaya bentuk batas keputusan.
\(\gamma\) besar: kernel “tajam” — setiap titik punya pengaruh lokal kuat (batas keputusan berlekuk); \(\gamma\) kecil: pengaruh lebih global / halus.
Di sklearn, gamma='scale' memakai \(1/(p \cdot \text{Var}(X))\) sebagai default heuristik.
SVM multi-kelas & praktik sklearn
Multi-kelas:SVC memakai strategi one-vs-one (setiap pasang kelas satu SVM); untuk banyak kelas jumlah sub-masalah \(O(C^2)\) — masih efisien untuk \(C\) kecil–sedang.
LinearSVC (bukan SVC(kernel='linear')) memakai optimisasi berbeda dan sering lebih cepat pada data besar berdimensi tinggi (mis. teks TF–IDF).
Skala fitur: SVM membandingkan kontribusi fitur lewat produk dalam / jarak — standarisasi (StandardScaler dalam Pipeline) hampir selalu wajib agar \(C\) dan \(\gamma\) bermakna.
Naive Bayes — bahasa awam
Naive Bayes seperti dokter yang mendengar beberapa gejala lalu bertanya dalam hati: “dari pengalaman statistik, masing-masing gejala ini seberapa sering muncul pada penyakit A vs B?” lalu menggabungkan jawaban dengan asumsi sederhana: gejala-gejala itu hampir tidak saling memengaruhi setelah penyakit diketahui (asumsi naif).
Di dunia nyata gejala sering saling berkaitan, tetapi trik ini membuat perhitungan sangat cepat dan sering cukup akurat (terutama teks spam/ham dengan representasi kata). Cocok sebagai baseline sebelum model yang lebih berat.
Naive Bayes (Gaussian)
Asumsi “naif”: antar fitur kondisional independen diberi kelas — jarang benar secara ketat, tetapi model sering cepat dan cukup kuat sebagai baseline.
GaussianNB: memodelkan setiap fitur per kelas dengan Gaussian univariat — cocok untuk fitur kontinu mendekati normal per kelas.
Kelebihan: latih sangat cepat; sedikit hiperparameter.
Kelemahan: asumsi independensi bisa melemahkan jika fitur sangat berkorelasi.
Grafik: Gaussian Naive Bayes — batas keputusan 2D
Model memisahkan ruang dengan permukaan yang mengasumsikan setiap fitur berkontribusi lewat kurva normal per kelas; visual membantu melihat kapan batas hampir linear vs lengkung.
Saat membandingkan k-NN, pohon, hutan, SVM, dan Naive Bayes, bayangkan satu ujian dengan soal yang sama (data uji identik) dan aturan main yang sama (cara hitung skor akurasi/F1). Yang berbeda hanya “strategi belajar” tiap algoritme: ada yang mengandalkan tetangga terdekat, ada yang membuat aturan cabang, ada yang mencari pembatas lebar, ada yang menghitung peluang gejala.
Tanpa aturan adil ini, mudah menyalahkan algoritme padahal yang bermasalah adalah skala fitur, outlier, atau kebocoran dari set uji ke proses latih.
Komparasi cepat: beberapa algoritme pada split yang sama
Confusion matrix seperti tabel absensi ujian: baris = jawaban sebenarnya, kolom = yang diprediksi model. Angka di diagonal utama = benar; di luar diagonal = jenis salah (misalnya sehat diprediksi sakit vs sebaliknya). Berguna ketika salah jenis A vs jenis B punya konsekuensi berbeda di dunia nyata (biaya, risiko).
Skenario & metrik harus ditetapkan sebelum mengutak-atik model; train/test dengan stratify untuk klasifikasi.
Bahasa awam: latih = latihan, uji = ujian suci; k-NN = voting tetangga; pohon = if–else; hutan = komite pohon; SVM = pembatas dengan “jalur aman”; Naive Bayes = menggabungkan peluang gejala dengan asumsi sederhana.
k-NN: klasifikator berbasis contoh; suara mayoritas (atau bobot jarak) di antara \(k\) tetangga terdekat; kompleksitas prediksi tinggi; jarak & penskalaan fitur menentukan geometri ruang.
Pohon & RF: pohon = partisi sumbu-sejajar + impurity (Gini/entropi) + split greedy; RF = ensemble pohon untuk turunkan varians.
SVM:margin maksimum; soft margin + \(C\); solusi lewat dual + kernel (RBF + \(\gamma\)); multi-kelas OvO di SVC.
GaussianNB: baseline cepat dengan asumsi independensi kondisional antar fitur.
Komparasi adil memakai split identik dan protokol preprocessing yang konsisten (Pipeline).
Grafik konsep: slide tambahan memakai make_moons / make_classification untuk batas keputusan k-NN, pohon, RF, SVM, dan Naive Bayes.
Referensi
James et al., ISL — klasifikasi, pohon, ensemble, SVM.