Prakata

Ebook ini disusun sebagai bahan ajar satu semester untuk mata kuliah machine learning berbasis R. Susunan materi mengikuti urutan belajar yang lebih logis: dimulai dari pengantar dan regresi, lalu regularisasi, reduksi dimensi, unsupervised learning, ensemble learning, metode supervised utama, neural network, evaluasi model, dan dua proyek besar pada UTS serta UAS.

Setiap bab memiliki format yang sama agar mudah dipakai untuk kuliah, belajar mandiri, maupun penyusunan slide:

Tujuan pembelajaran.
Konsep inti dan definisi.
Formulasi matematis.
Contoh implementasi dengan R.
Tugas.
Kuis singkat.
Ringkasan.

Catatan penting:

Seluruh chunk contoh kini diset untuk dieksekusi agar output model, tabel, dan grafik muncul pada dokumen hasil knit.
Chunk instalasi paket tetap tidak dieksekusi otomatis agar proses render tidak mencoba mengunduh ulang paket.
Contoh data memakai dataset yang umum di R seperti iris, mtcars, USArrests, dan AirPassengers.

Cara Menggunakan Ebook Ini

0.1 Sasaran Pembaca

Ebook ini cocok untuk:

mahasiswa yang baru mulai belajar machine learning,
dosen atau asisten yang ingin bahan ajar berurutan,
pembaca yang ingin memahami teori sekaligus praktik R.

0.2 Capaian Akhir Mata Kuliah

Setelah menyelesaikan seluruh buku ini, pembaca diharapkan mampu:

Menjelaskan konsep dasar machine learning dan alur kerja analisis data modern.
Mengimplementasikan model regresi, klasifikasi, clustering, dan reduksi dimensi di R.
Memilih metode yang sesuai dengan karakteristik data dan tujuan analisis.
Mengevaluasi model dengan prosedur validasi yang benar.
Menyusun proyek machine learning yang reprodusibel dan dapat dipresentasikan.

0.3 Persiapan Paket R

paket <- c(
  "tidyverse", "glmnet", "cluster", "e1071", "class",
  "rpart", "rpart.plot", "randomForest", "gbm", "nnet"
)

install.packages(setdiff(paket, rownames(installed.packages())))

0.4 Notasi yang Dipakai

Notasi	Arti
\(n\)	banyak observasi
\(p\)	banyak fitur atau prediktor
\(\mathbf{X}\)	matriks fitur berukuran \(n \times p\)
\(\mathbf{y}\)	vektor target
\(\hat{y}\)	prediksi model
\(\beta\)	parameter regresi
\(\lambda\)	parameter regularisasi
\(k\)	jumlah tetangga atau jumlah cluster, tergantung konteks
\(L(\cdot)\)	loss function
\(f(\cdot)\)	fungsi model

Peta Buku

Pertemuan	Topik	Fokus Utama	Penanggung Jawab
1	Perkenalan Machine Learning	ruang lingkup, tipe masalah, pipeline	Mindra
2	Analisis Regresi dan Gradient Descent	fondasi supervised learning	Mindra
3	Ridge, Lasso, Elastic Net	regularisasi dan seleksi fitur	Mindra
4	PCA dan Analisis Faktor	reduksi dimensi dan variabel laten	Irland
5	Hierarchical Clustering dan K-Medoids	clustering berbasis jarak	Irland
6	K-Means dan Fuzzy C-Means	clustering partisional dan fuzzy	Irland
7	Gradient Boosting untuk Regresi dan Time Series	ensemble boosting	Mindra
8	UTS Project	desain dan pelaporan proyek	Tim
9	Naive Bayes dan K-NN	klasifikasi probabilistik dan instance-based	Irland
10	Decision Tree	pemisahan berbasis aturan	Irland
11	Random Forest	bagging dan random subspace	Irland
12	SVM	margin maksimum dan kernel	Mindra
13	SVR	regresi berbasis support vectors	Mindra
14	Neural Network dan Deep Learning	model berlapis dan backpropagation	Mindra
15	Validation dan Evaluation	hold-out, k-fold, confusion matrix	Irland
16	UAS Project	proyek akhir, presentasi, dan report	Tim

1 Perkenalan Machine Learning

1.1 Tujuan Pembelajaran

Setelah mempelajari bab ini, pembaca mampu:

Mendefinisikan machine learning secara konseptual dan formal.
Membedakan supervised, unsupervised, semi-supervised, dan reinforcement learning.
Menjelaskan pipeline dasar machine learning dari data mentah sampai evaluasi.
Membedakan orientasi prediksi dan orientasi inferensi.

1.2 Definisi dan Intuisi

Machine learning adalah pendekatan komputasional untuk membangun sistem yang dapat belajar dari data, menemukan pola, lalu menggunakan pola tersebut untuk membuat prediksi atau keputusan. Berbeda dari pemrograman tradisional yang mensyaratkan aturan eksplisit, machine learning membiarkan model “mempelajari” aturan dari data historis.

Secara formal, kita ingin membangun fungsi:

\[ \hat{y} = f(\mathbf{x}; \theta) \]

dengan:

\(\mathbf{x}\): fitur atau input,
\(\hat{y}\): output prediksi,
\(\theta\): parameter model yang dipelajari dari data.

Proses belajar dilakukan dengan meminimalkan fungsi kerugian:

\[ \hat{\theta} = \arg\min_{\theta} \sum_{i=1}^n L(y_i, f(x_i; \theta)) \]

1.3 Jenis Masalah Machine Learning

1.3.1 Supervised Learning

Data memiliki pasangan input-output. Tujuan model adalah mempelajari hubungan antara prediktor dan target.

Contoh:

prediksi harga rumah,
prediksi risiko kredit,
klasifikasi email spam.

1.3.2 Unsupervised Learning

Data tidak memiliki label target. Model mencari struktur tersembunyi, misalnya cluster atau dimensi laten.

Contoh:

segmentasi pelanggan,
pengelompokan daerah berdasarkan indikator sosial,
reduksi dimensi.

1.3.3 Semi-Supervised Learning

Sebagian data berlabel, sebagian tidak. Pendekatan ini umum pada kasus di mana label mahal untuk diperoleh.

1.3.4 Reinforcement Learning

Agent belajar melalui interaksi dengan lingkungan dan menerima reward. Fokusnya pada strategi keputusan berurutan.

1.4 Pipeline Dasar Machine Learning

Urutan kerja minimum yang sehat adalah:

Rumuskan masalah.
Pahami target bisnis atau target akademik.
Kumpulkan dan bersihkan data.
Lakukan eksplorasi data.
Bagi data menjadi train, validation, dan test jika perlu.
Bangun baseline model.
Latih model yang lebih kuat.
Evaluasi, interpretasi, dan komunikasikan hasil.

1.5 Machine Learning vs Statistik Klasik

Perbedaan paling penting bukan pada alatnya, melainkan pada fokus analisis:

Statistik klasik banyak menekankan inferensi, pengujian hipotesis, dan interpretasi parameter.
Machine learning lebih menekankan akurasi prediksi dan generalisasi ke data baru.

Keduanya saling melengkapi. Regresi linear, misalnya, bisa dipakai sebagai model inferensial maupun model prediktif, tergantung pertanyaan riset dan cara evaluasinya.

1.6 Contoh R: Split Data Sederhana

set.seed(123)
idx <- sample(seq_len(nrow(iris)), size = 0.7 * nrow(iris))
train_data <- iris[idx, ]
test_data  <- iris[-idx, ]

dim(train_data)

#> [1] 105   5

dim(test_data)

#> [1] 45  5

table(train_data$Species)

#> 
#>     setosa versicolor  virginica 
#>         36         32         37

table(test_data$Species)

#> 
#>     setosa versicolor  virginica 
#>         14         18         13

1.7 Tugas

Berikan 5 contoh masalah nyata yang bisa diselesaikan dengan machine learning.
Untuk masing-masing contoh, tentukan apakah termasuk regresi, klasifikasi, clustering, atau reduksi dimensi.
Jelaskan target, fitur, dan metrik evaluasi yang cocok untuk dua contoh pilihan Anda.

1.8 Kuis Singkat

Apa perbedaan utama supervised dan unsupervised learning?
Mengapa data latih yang bagus belum tentu menghasilkan model yang bagus?
Apa arti generalisasi dalam machine learning?
Sebutkan dua contoh loss function.
Mengapa baseline model penting?

1.9 Ringkasan

Machine learning mempelajari pola dari data untuk menghasilkan prediksi atau keputusan. Fokus utamanya adalah generalisasi, bukan sekadar cocok pada data latih. Seluruh bab berikutnya pada dasarnya adalah variasi dari ide yang sama: memilih bentuk fungsi \(f(\cdot)\), menentukan loss, melatih model, dan mengevaluasinya pada data yang belum pernah dilihat.

2 Analisis Regresi dan Gradient Descent

2.1 Tujuan Pembelajaran

Setelah menyelesaikan bab ini, pembaca mampu:

Menjelaskan regresi linear sebagai fondasi supervised learning.
Menurunkan fungsi loss mean squared error.
Memahami solusi OLS dan pendekatan iteratif gradient descent.
Mengimplementasikan regresi linear dan gradient descent di R.

2.2 Regresi Linear sebagai Fondasi

Regresi linear berganda dinyatakan sebagai:

\[ y_i = \beta_0 + \beta_1 x_{i1} + \beta_2 x_{i2} + \cdots + \beta_p x_{ip} + \varepsilon_i \]

dalam bentuk matriks:

\[ \mathbf{y} = \mathbf{X}\beta + \varepsilon \]

Tujuan utamanya adalah mencari \(\beta\) yang meminimalkan galat kuadrat.

2.3 Fungsi Loss

Loss yang paling umum untuk regresi adalah Mean Squared Error:

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

dengan:

\[ \hat{y}_i = \beta_0 + \sum_{j=1}^{p}\beta_j x_{ij} \]

Secara matriks, objective function dapat ditulis:

\[ J(\beta) = \frac{1}{n}(\mathbf{y} - \mathbf{X}\beta)^\top(\mathbf{y} - \mathbf{X}\beta) \]

2.4 Solusi OLS

Jika \(\mathbf{X}^\top\mathbf{X}\) invertibel, estimator ordinary least squares adalah:

\[ \hat{\beta}_{OLS} = (\mathbf{X}^\top\mathbf{X})^{-1}\mathbf{X}^\top \mathbf{y} \]

Solusi ini efisien dan elegan, tetapi pada data besar atau model kompleks sering lebih nyaman memakai optimisasi iteratif.

2.5 Gradient Descent

Gradient descent memperbarui parameter sedikit demi sedikit mengikuti arah negatif gradien:

\[ \beta^{(t+1)} = \beta^{(t)} - \eta \nabla J(\beta^{(t)}) \]

untuk regresi linear:

\[ \nabla J(\beta) = \frac{2}{n}\mathbf{X}^\top(\mathbf{X}\beta - \mathbf{y}) \]

sehingga:

\[ \beta^{(t+1)} = \beta^{(t)} - \eta \frac{2}{n}\mathbf{X}^\top(\mathbf{X}\beta^{(t)} - \mathbf{y}) \]

Keterangan:

\(\eta\) adalah learning rate,
iterasi berhenti saat loss sudah stabil atau jumlah epoch tercapai.

2.6 Kapan Gradient Descent Dipakai?

Gradient descent sangat penting ketika:

jumlah fitur besar,
model tidak punya solusi analitik sederhana,
loss function kompleks,
kita beralih ke neural network dan deep learning.

2.7 Contoh R: Regresi Linear dengan `lm()`

model_lm <- lm(mpg ~ wt + hp, data = mtcars)
summary(model_lm)

#> 
#> Call:
#> lm(formula = mpg ~ wt + hp, data = mtcars)
#> 
#> Residuals:
#>    Min     1Q Median     3Q    Max 
#> -3.941 -1.600 -0.182  1.050  5.854 
#> 
#> Coefficients:
#>             Estimate Std. Error t value             Pr(>|t|)    
#> (Intercept) 37.22727    1.59879  23.285 < 0.0000000000000002 ***
#> wt          -3.87783    0.63273  -6.129           0.00000112 ***
#> hp          -0.03177    0.00903  -3.519              0.00145 ** 
#> ---
#> Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
#> 
#> Residual standard error: 2.593 on 29 degrees of freedom
#> Multiple R-squared:  0.8268, Adjusted R-squared:  0.8148 
#> F-statistic: 69.21 on 2 and 29 DF,  p-value: 0.000000000009109

pred_lm <- predict(model_lm, newdata = mtcars)
rmse_lm <- sqrt(mean((mtcars$mpg - pred_lm)^2))
rmse_lm

#> [1] 2.468854

2.8 Contoh R: Gradient Descent Manual

dat <- mtcars[, c("mpg", "wt", "hp")]
y <- dat$mpg
x <- scale(as.matrix(dat[, c("wt", "hp")]))
X <- cbind(1, x)

beta <- rep(0, ncol(X))
eta <- 0.05
epochs <- 5000
loss_history <- numeric(epochs)

for (t in seq_len(epochs)) {
  error <- X %*% beta - y
  grad  <- (2 / nrow(X)) * t(X) %*% error
  beta  <- beta - eta * grad
  loss_history[t] <- mean(error^2)
}

beta

#>         [,1]
#>    20.090625
#> wt -3.794292
#> hp -2.178444

tail(loss_history)

#> [1] 6.095242 6.095242 6.095242 6.095242 6.095242 6.095242

plot(loss_history, type = "l", col = "blue", lwd = 2,
     main = "Konvergensi Gradient Descent",
     xlab = "Epoch", ylab = "MSE")

2.9 Interpretasi

Beberapa poin penting dari regresi linear:

koefisien menunjukkan perubahan rata-rata target terhadap perubahan fitur, dengan fitur lain tetap,
MSE mengukur besar galat kuadrat rata-rata,
gradient descent tidak harus langsung akurat; kuncinya adalah konvergen secara stabil.

2.10 Tugas

Gunakan dataset mtcars untuk memprediksi mpg dengan minimal tiga prediktor.
Bandingkan hasil lm() dengan implementasi gradient descent manual.
Uji tiga learning rate berbeda dan jelaskan pengaruhnya terhadap konvergensi.

2.11 Kuis Singkat

Apa perbedaan solusi OLS dan gradient descent?
Mengapa fitur sering perlu diskalakan sebelum gradient descent?
Apa yang terjadi jika learning rate terlalu besar?
Apa makna MSE yang kecil?
Mengapa regresi linear sering dipakai sebagai baseline?

2.12 Ringkasan

Regresi linear adalah jembatan paling natural antara statistika dan machine learning. Dari sini pembaca belajar bahwa model adalah fungsi, pelatihan adalah optimisasi, dan kualitas model ditentukan oleh performa prediksi serta kestabilannya.

3 Ridge, Lasso, dan Elastic Net

3.1 Tujuan Pembelajaran

Pembaca diharapkan mampu:

Menjelaskan masalah overfitting dan multikolinearitas.
Menuliskan objective function Ridge, Lasso, dan Elastic Net.
Memahami peran parameter regularisasi.
Mengimplementasikan regularisasi menggunakan glmnet.

3.2 Mengapa Regularisasi Penting?

Pada data dengan banyak prediktor atau korelasi tinggi antarprediktor, OLS bisa menghasilkan koefisien yang tidak stabil. Model juga dapat terlalu menyesuaikan data latih sehingga performanya turun pada data baru. Regularisasi menambahkan penalti pada besar koefisien agar model lebih sederhana dan stabil.

3.3 Ridge Regression

Objective function Ridge:

\[ \min_{\beta_0,\beta} \left\{ \sum_{i=1}^{n}(y_i - \beta_0 - x_i^\top\beta)^2 + \lambda \sum_{j=1}^{p}\beta_j^2 \right\} \]

Karakteristik:

memakai penalti \(L_2\),
menyusutkan koefisien mendekati nol,
tidak melakukan seleksi variabel secara keras.

3.4 Lasso Regression

Objective function Lasso:

\[ \min_{\beta_0,\beta} \left\{ \sum_{i=1}^{n}(y_i - \beta_0 - x_i^\top\beta)^2 + \lambda \sum_{j=1}^{p}|\beta_j| \right\} \]

Karakteristik:

memakai penalti \(L_1\),
dapat membuat sebagian koefisien tepat nol,
cocok untuk seleksi fitur.

3.5 Elastic Net

Elastic Net menggabungkan penalti \(L_1\) dan \(L_2\):

\[ \min_{\beta_0,\beta} \left\{ \sum_{i=1}^{n}(y_i - \beta_0 - x_i^\top\beta)^2 + \lambda \left[(1-\alpha)\sum_{j=1}^{p}\beta_j^2/2 + \alpha \sum_{j=1}^{p}|\beta_j|\right] \right\} \]

dengan:

\(\alpha = 0\) setara Ridge,
\(\alpha = 1\) setara Lasso,
\(0 < \alpha < 1\) memberi kompromi.

3.6 Intuisi Geometris

Ridge membuat daerah kendala berbentuk lingkaran.
Lasso membuat daerah kendala berbentuk belah ketupat sehingga solusi lebih sering jatuh di sudut, yaitu koefisien nol.
Elastic Net menyeimbangkan stabilitas Ridge dan sparsity Lasso.

3.7 Contoh R: Ridge, Lasso, Elastic Net dengan `glmnet`

library(glmnet)

x <- model.matrix(mpg ~ ., data = mtcars)[, -1]
y <- mtcars$mpg

cv_ridge <- cv.glmnet(x, y, alpha = 0)
cv_lasso <- cv.glmnet(x, y, alpha = 1)
cv_enet  <- cv.glmnet(x, y, alpha = 0.5)

coef(cv_ridge, s = "lambda.min")

#> 11 x 1 sparse Matrix of class "dgCMatrix"
#>               lambda.min
#> (Intercept) 20.974654745
#> cyl         -0.376364874
#> disp        -0.005370836
#> hp          -0.011393558
#> drat         1.055717325
#> wt          -1.175325163
#> qsec         0.158738999
#> vs           0.801360486
#> am           1.558830973
#> gear         0.539424986
#> carb        -0.521508008

coef(cv_lasso, s = "lambda.min")

#> 11 x 1 sparse Matrix of class "dgCMatrix"
#>              lambda.min
#> (Intercept) 17.97054403
#> cyl         -0.13048617
#> disp         .         
#> hp          -0.01299374
#> drat         0.81635748
#> wt          -2.63483901
#> qsec         0.51900822
#> vs           0.12811186
#> am           2.21741376
#> gear         0.42898828
#> carb        -0.50776070

coef(cv_enet,  s = "lambda.min")

#> 11 x 1 sparse Matrix of class "dgCMatrix"
#>               lambda.min
#> (Intercept) 31.441460703
#> cyl         -0.651622903
#> disp        -0.001531276
#> hp          -0.014184057
#> drat         0.584812825
#> wt          -2.083724697
#> qsec         .          
#> vs           0.276206167
#> am           1.131837728
#> gear         .          
#> carb        -0.307590466

plot(cv_ridge)

plot(cv_lasso)

plot(cv_enet)

3.8 Hal Praktis yang Perlu Diingat

Standardisasi fitur hampir selalu diperlukan pada regularisasi.
Pilih \(\lambda\) dengan cross-validation.
Jika semua variabel penting dan berkorelasi tinggi, Ridge sering lebih stabil.
Jika ingin model ringkas dan seleksi fitur, Lasso menarik.
Jika fitur berkorelasi dan tetap ingin seleksi, Elastic Net sering paling aman.

3.9 Tugas

Gunakan mtcars atau dataset lain untuk membandingkan OLS, Ridge, Lasso, dan Elastic Net.
Catat variabel mana yang dipertahankan oleh Lasso.
Bandingkan RMSE test set dari keempat model.

3.10 Kuis Singkat

Apa bedanya penalti \(L_1\) dan \(L_2\)?
Mengapa Lasso bisa melakukan seleksi variabel?
Kapan Ridge lebih disukai daripada Lasso?
Apa fungsi lambda.min pada cv.glmnet?
Mengapa regularisasi dapat menurunkan variance?

3.11 Ringkasan

Regularisasi adalah alat utama untuk menjaga model tetap stabil dan tidak terlalu kompleks. Ridge menurunkan variance, Lasso memberi seleksi fitur, dan Elastic Net menggabungkan keduanya.

4 Reduksi Dimensi: PCA dan Analisis Faktor

4.1 Tujuan Pembelajaran

Setelah bab ini, pembaca mampu:

Menjelaskan motivasi reduksi dimensi.
Menurunkan ide dasar principal component analysis.
Membedakan PCA dan analisis faktor.
Menggunakan prcomp() dan factanal() di R.

4.2 Mengapa Reduksi Dimensi?

Reduksi dimensi diperlukan ketika:

jumlah variabel banyak,
variabel saling berkorelasi,
visualisasi dua atau tiga dimensi dibutuhkan,
model rawan overfitting.

4.3 Principal Component Analysis

PCA mencari kombinasi linear dari variabel asal yang memaksimalkan variasi.

Komponen pertama:

\[ z_1 = a_{11}x_1 + a_{12}x_2 + \cdots + a_{1p}x_p \]

dengan kendala:

\[ \sum_{j=1}^{p} a_{1j}^2 = 1 \]

dan dipilih agar:

\[ \mathrm{Var}(z_1) \]

maksimum. Secara matriks, solusi diperoleh dari eigen decomposition matriks kovarians atau korelasi.

Jika \(\mathbf{S}\) adalah matriks kovarians, maka:

\[ \mathbf{S} a_k = \lambda_k a_k \]

dengan:

\(a_k\): eigenvector atau loading,
\(\lambda_k\): eigenvalue atau varian komponen ke-\(k\).

4.4 Analisis Faktor

Analisis faktor berangkat dari asumsi bahwa variabel teramati dipengaruhi oleh faktor laten:

\[ \mathbf{x} = \mu + \Lambda \mathbf{f} + \epsilon \]

dengan:

\(\Lambda\): matriks loading faktor,
\(\mathbf{f}\): faktor laten,
\(\epsilon\): error unik.

Struktur kovarians:

\[ \Sigma = \Lambda \Phi \Lambda^\top + \Psi \]

PCA berfokus pada kompresi variasi, sedangkan analisis faktor berfokus pada konstruk laten yang menjelaskan korelasi antarvariabel.

4.5 Perbedaan PCA vs Analisis Faktor

Aspek	PCA	Analisis Faktor
Tujuan	reduksi dimensi	menemukan faktor laten
Dasar	total variance	common variance
Output utama	principal components	factor loadings
Cocok untuk	visualisasi, kompresi	konstruk psikometrik, sosial, ekonomi

4.6 Contoh R: PCA

pca_fit <- prcomp(USArrests, scale. = TRUE)
summary(pca_fit)

#> Importance of components:
#>                           PC1    PC2     PC3     PC4
#> Standard deviation     1.5749 0.9949 0.59713 0.41645
#> Proportion of Variance 0.6201 0.2474 0.08914 0.04336
#> Cumulative Proportion  0.6201 0.8675 0.95664 1.00000

pca_fit$rotation

#>                 PC1        PC2        PC3         PC4
#> Murder   -0.5358995 -0.4181809  0.3412327  0.64922780
#> Assault  -0.5831836 -0.1879856  0.2681484 -0.74340748
#> UrbanPop -0.2781909  0.8728062  0.3780158  0.13387773
#> Rape     -0.5434321  0.1673186 -0.8177779  0.08902432

pca_fit$x[1:10, ]

#>                     PC1         PC2         PC3          PC4
#> Alabama     -0.97566045 -1.12200121  0.43980366  0.154696581
#> Alaska      -1.93053788 -1.06242692 -2.01950027 -0.434175454
#> Arizona     -1.74544285  0.73845954 -0.05423025 -0.826264240
#> Arkansas     0.13999894 -1.10854226 -0.11342217 -0.180973554
#> California  -2.49861285  1.52742672 -0.59254100 -0.338559240
#> Colorado    -1.49934074  0.97762966 -1.08400162  0.001450164
#> Connecticut  1.34499236  1.07798362  0.63679250 -0.117278736
#> Delaware    -0.04722981  0.32208890  0.71141032 -0.873113315
#> Florida     -2.98275967 -0.03883425  0.57103206 -0.095317042
#> Georgia     -1.62280742 -1.26608838  0.33901818  1.065974459

biplot(pca_fit, cex = 0.7)

4.7 Contoh R: Analisis Faktor

fa_fit <- factanal(USArrests, factors = 1, rotation = "varimax",
                   scores = "regression")

print(fa_fit, digits = 2, cutoff = 0.30)

#> 
#> Call:
#> factanal(x = USArrests, factors = 1, scores = "regression", rotation = "varimax")
#> 
#> Uniquenesses:
#>   Murder  Assault UrbanPop     Rape 
#>     0.33     0.04     0.93     0.53 
#> 
#> Loadings:
#>          Factor1
#> Murder   0.82   
#> Assault  0.98   
#> UrbanPop        
#> Rape     0.68   
#> 
#>                Factor1
#> SS loadings       2.16
#> Proportion Var    0.54
#> 
#> Test of the hypothesis that 1 factor is sufficient.
#> The chi square statistic is 9.15 on 2 degrees of freedom.
#> The p-value is 0.0103

fa_fit$loadings

#> 
#> Loadings:
#>          Factor1
#> Murder   0.818  
#> Assault  0.979  
#> UrbanPop 0.262  
#> Rape     0.683  
#> 
#>                Factor1
#> SS loadings      2.162
#> Proportion Var   0.540

fa_fit$scores[1:10, ]

#>     Alabama      Alaska     Arizona    Arkansas  California    Colorado 
#>   0.7901515   1.1161087   1.3553508   0.2025243   1.2423296   0.4472463 
#> Connecticut    Delaware     Florida     Georgia 
#>  -0.7724846   0.6409789   1.9416162   0.6412841

Catatan:

USArrests hanya memiliki 4 variabel, sehingga contoh yang aman untuk factanal() adalah 1 factor.
Jika ingin demonstrasi 2 factor, gunakan dataset dengan variabel lebih banyak agar model teridentifikasi dengan baik.

4.8 Panduan Interpretasi

Lihat proporsi varian kumulatif untuk menentukan banyak komponen PCA.
Loading besar secara absolut menunjukkan kontribusi kuat variabel pada komponen atau faktor.
Pada analisis faktor, rotasi seperti varimax memudahkan interpretasi substantif.

4.9 Tugas

Terapkan PCA pada dataset numerik yang memiliki minimal 5 variabel.
Buat scree plot dan tentukan jumlah komponen yang dipertahankan.
Lakukan analisis faktor dan bandingkan interpretasinya dengan PCA.

4.10 Kuis Singkat

Apa perbedaan tujuan PCA dan analisis faktor?
Apa arti eigenvalue besar pada PCA?
Mengapa standardisasi penting pada PCA?
Apa fungsi rotasi varimax?
Kapan reduksi dimensi sebaiknya dilakukan sebelum modeling?

4.11 Ringkasan

PCA meringkas variasi data ke beberapa komponen utama, sedangkan analisis faktor memodelkan struktur laten di balik korelasi antarfaktor. Keduanya sangat berguna untuk eksplorasi dan penyederhanaan data berdimensi tinggi.

5 Unsupervised Learning I: Hierarchical Clustering dan K-Medoids

5.1 Tujuan Pembelajaran

Pembaca mampu:

Menjelaskan konsep clustering berbasis jarak.
Membedakan hierarchical clustering dan K-medoids.
Memilih linkage method yang sesuai.
Mengimplementasikan kedua metode di R.

5.2 Konsep Clustering

Clustering bertujuan mengelompokkan observasi yang mirip dalam cluster yang sama dan memisahkan observasi yang tidak mirip ke cluster berbeda. Tidak ada label target, sehingga fokusnya pada struktur internal data.

5.3 Ukuran Jarak

Ukuran jarak yang sering dipakai:

Euclidean distance,
Manhattan distance,
Gower distance untuk data campuran.

Untuk dua observasi \(x_i\) dan \(x_j\), jarak Euclidean:

\[ d(x_i, x_j) = \sqrt{\sum_{m=1}^{p}(x_{im} - x_{jm})^2} \]

5.4 Hierarchical Clustering

Hierarchical clustering membangun struktur pohon atau dendrogram.

Dua pendekatan utama:

agglomerative: mulai dari tiap observasi sebagai cluster sendiri lalu digabung,
divisive: mulai dari satu cluster besar lalu dipecah.

Linkage yang umum:

single linkage: jarak minimum antaranggota,
complete linkage: jarak maksimum antaranggota,
average linkage: rata-rata jarak,
Ward: meminimalkan kenaikan within-cluster variance.

5.5 K-Medoids

K-medoids mirip K-means, tetapi pusat cluster adalah observasi aktual, bukan rata-rata. Ini membuatnya lebih tahan terhadap outlier.

Objective function:

\[ \min \sum_{k=1}^{K}\sum_{i \in C_k} d(x_i, m_k) \]

dengan \(m_k\) adalah medoid cluster ke-\(k\).

5.6 Contoh R: Hierarchical Clustering

scaled_data <- scale(USArrests)
d <- dist(scaled_data, method = "euclidean")

hc_complete <- hclust(d, method = "complete")
plot(hc_complete, main = "Dendrogram Complete Linkage")

cluster_hc <- cutree(hc_complete, k = 3)
table(cluster_hc)

#> cluster_hc
#>  1  2  3 
#>  8 11 31

5.7 Contoh R: K-Medoids dengan `pam()`

library(cluster)

pam_fit <- pam(scaled_data, k = 3)
pam_fit$medoids

#>                   Murder    Assault   UrbanPop       Rape
#> New Mexico     0.8292944  1.3708088  0.3081225  1.1603196
#> Oklahoma      -0.2727580 -0.2371077  0.1699510 -0.1315342
#> New Hampshire -1.3059321 -1.3650491 -0.6590781 -1.2525644

table(pam_fit$clustering)

#> 
#>  1  2  3 
#> 19 21 10

plot(pam_fit)

5.8 Evaluasi Clustering

Beberapa alat evaluasi:

silhouette width,
interpretasi substantif,
kestabilan hasil,
kemudahan menjelaskan cluster.

5.9 Tugas

Lakukan hierarchical clustering pada USArrests dengan tiga linkage berbeda.
Bandingkan komposisi cluster yang dihasilkan.
Lakukan K-medoids dan bandingkan dengan hierarchical clustering.

5.10 Kuis Singkat

Mengapa hierarchical clustering menghasilkan dendrogram?
Apa keunggulan K-medoids dibanding K-means?
Apa perbedaan single dan complete linkage?
Mengapa standardisasi penting dalam clustering berbasis jarak?
Apakah clustering memiliki “label benar” seperti klasifikasi?

5.11 Ringkasan

Hierarchical clustering memberi gambaran struktur data secara bertingkat, sedangkan K-medoids lebih robust terhadap outlier. Keduanya cocok untuk eksplorasi segmentasi pada data tanpa label.

6 Unsupervised Learning II: K-Means dan Fuzzy C-Means

6.1 Tujuan Pembelajaran

Setelah bab ini, pembaca mampu:

Menjelaskan objective function K-means.
Memahami konsep keanggotaan fuzzy pada FCM.
Membedakan cluster tegas dan cluster lunak.
Menggunakan K-means dan FCM di R.

6.2 K-Means

K-means membagi data ke dalam \(K\) cluster dengan meminimalkan within-cluster sum of squares:

\[ \min \sum_{k=1}^{K}\sum_{i \in C_k} \lVert x_i - \mu_k \rVert^2 \]

Algoritmanya:

Inisialisasi centroid.
Tetapkan tiap observasi ke centroid terdekat.
Perbarui centroid sebagai rata-rata cluster.
Ulangi sampai stabil.

6.3 Kelebihan dan Kelemahan K-Means

Kelebihan:

cepat,
mudah diimplementasikan,
cocok untuk data numerik skala besar.

Kelemahan:

sensitif terhadap inisialisasi,
sensitif terhadap outlier,
mengasumsikan cluster relatif bulat.

6.4 Fuzzy C-Means

FCM mengizinkan satu observasi memiliki derajat keanggotaan di lebih dari satu cluster.

Objective function:

\[ J_m = \sum_{i=1}^{n}\sum_{k=1}^{c} u_{ik}^{m} \lVert x_i - v_k \rVert^2 \]

dengan:

\(u_{ik}\): derajat keanggotaan observasi \(i\) pada cluster \(k\),
\(m > 1\): fuzzifier,
\(v_k\): pusat cluster ke-\(k\).

Kendala:

\[ \sum_{k=1}^{c} u_{ik} = 1 \quad \text{untuk setiap } i \]

6.5 Update Rule FCM

Pusat cluster:

\[ v_k = \frac{\sum_{i=1}^{n}u_{ik}^{m} x_i}{\sum_{i=1}^{n}u_{ik}^{m}} \]

Keanggotaan:

\[ u_{ik} = \frac{1}{\sum_{\ell=1}^{c}\left( \frac{\lVert x_i - v_k \rVert}{\lVert x_i - v_\ell \rVert} \right)^{\frac{2}{m-1}}} \]

6.6 Contoh R: K-Means

scaled_iris <- scale(iris[, -5])

kmeans_fit <- kmeans(scaled_iris, centers = 3, nstart = 25)
kmeans_fit$centers

#>   Sepal.Length Sepal.Width Petal.Length Petal.Width
#> 1   1.13217737  0.08812645    0.9928284   1.0141287
#> 2  -0.05005221 -0.88042696    0.3465767   0.2805873
#> 3  -1.01119138  0.85041372   -1.3006301  -1.2507035

table(Cluster = kmeans_fit$cluster, Species = iris$Species)

#>        Species
#> Cluster setosa versicolor virginica
#>       1      0         11        36
#>       2      0         39        14
#>       3     50          0         0

6.7 Contoh R: Fuzzy C-Means

library(e1071)

fcm_fit <- cmeans(scaled_iris, centers = 3, m = 2)
head(fcm_fit$membership)

#>                1         2           3
#> [1,] 0.005296014 0.9915693 0.003134719
#> [2,] 0.119219440 0.8289426 0.051837932
#> [3,] 0.047305380 0.9293800 0.023314622
#> [4,] 0.089186568 0.8695193 0.041294084
#> [5,] 0.016047567 0.9739414 0.010011068
#> [6,] 0.101994225 0.8188015 0.079204320

table(apply(fcm_fit$membership, 1, which.max), iris$Species)

#>    
#>     setosa versicolor virginica
#>   1      0         39        13
#>   2     50          0         0
#>   3      0         11        37

6.8 Memilih Jumlah Cluster

Beberapa pendekatan:

elbow method,
silhouette,
gap statistic,
justifikasi substantif.

6.9 Tugas

Terapkan K-means pada iris dan bandingkan hasil cluster dengan spesies asli.
Jalankan K-means dengan beberapa nilai nstart.
Terapkan FCM dan interpretasikan observasi yang memiliki keanggotaan campuran.

6.10 Kuis Singkat

Apa perbedaan cluster keras dan cluster fuzzy?
Mengapa K-means sensitif terhadap inisialisasi awal?
Apa peran parameter \(m\) pada FCM?
Mengapa FCM berguna untuk data dengan batas cluster yang kabur?
Bagaimana cara memilih jumlah cluster yang baik?

6.11 Ringkasan

K-means cocok untuk pengelompokan cepat dan sederhana, sedangkan FCM lebih fleksibel karena mengizinkan keanggotaan parsial. Dalam banyak aplikasi sosial dan bisnis, pendekatan fuzzy sering lebih realistis.

7 Gradient Boosting untuk Analisis Regresi dan Time Series

7.1 Tujuan Pembelajaran

Pembaca mampu:

Menjelaskan ide boosting sebagai pembelajaran sekuensial.
Menuliskan model aditif pada gradient boosting.
Menggunakan gradient boosting untuk regresi.
Mengubah masalah time series menjadi supervised learning berbasis lag.

7.2 Intuisi Gradient Boosting

Boosting membangun model secara bertahap. Setiap model baru mencoba memperbaiki kesalahan model sebelumnya. Gradient boosting merumuskan proses ini sebagai optimisasi loss dengan mengikuti arah negative gradient.

Model aditif:

\[ F_M(x) = F_{M-1}(x) + \nu \gamma_m h_m(x) \]

dengan:

\(F_M(x)\): model pada iterasi ke-\(M\),
\(\nu\): learning rate,
\(h_m(x)\): weak learner, biasanya tree kecil,
\(\gamma_m\): ukuran langkah.

Untuk squared error loss, residual menjadi target pada iterasi berikutnya.

7.3 Mengapa Boosting Kuat?

dapat memodelkan relasi non-linear,
mampu menangkap interaksi,
sering berperforma tinggi tanpa feature engineering ekstrem.

Namun:

rawan overfitting jika parameter tidak dikontrol,
tuning lebih penting daripada pada model linear.

7.4 Parameter Penting

n.trees: jumlah pohon,
interaction.depth: kedalaman pohon,
shrinkage: learning rate,
bag.fraction: proporsi data untuk tiap iterasi.

7.5 Contoh R: Gradient Boosting untuk Regresi

library(gbm)

set.seed(123)
gbm_fit <- gbm(
  mpg ~ .,
  data = mtcars,
  distribution = "gaussian",
  n.trees = 2000,
  interaction.depth = 3,
  shrinkage = 0.01,
  cv.folds = 5,
  n.minobsinnode = 5
)

best_iter <- gbm.perf(gbm_fit, method = "cv")

summary(gbm_fit, n.trees = best_iter)

#>       var    rel.inf
#> disp disp 21.5546392
#> hp     hp 20.3775283
#> cyl   cyl 20.1763731
#> wt     wt 13.9846179
#> qsec qsec  9.1057106
#> drat drat  7.2886519
#> carb carb  3.0400758
#> vs     vs  1.8632136
#> am     am  1.6843181
#> gear gear  0.9248715

pred_gbm <- predict(gbm_fit, newdata = mtcars, n.trees = best_iter)
sqrt(mean((mtcars$mpg - pred_gbm)^2))

#> [1] 1.098624

7.6 Time Series sebagai Supervised Learning

Banyak metode machine learning untuk time series bekerja setelah deret waktu diubah menjadi fitur lag. Misalnya:

\[ y_t = f(y_{t-1}, y_{t-2}, \ldots, y_{t-p}, t, \text{variabel eksogen}) \]

7.7 Contoh R: Gradient Boosting untuk Time Series

library(gbm)

ap <- as.numeric(AirPassengers)
lag_df <- data.frame(
  y     = ap[13:length(ap)],
  lag1  = ap[12:(length(ap) - 1)],
  lag12 = ap[1:(length(ap) - 12)],
  trend = 13:length(ap)
)

train_ts <- lag_df[1:100, ]
test_ts  <- lag_df[101:nrow(lag_df), ]

gbm_ts <- gbm(
  y ~ lag1 + lag12 + trend,
  data = train_ts,
  distribution = "gaussian",
  n.trees = 1500,
  interaction.depth = 2,
  shrinkage = 0.01,
  n.minobsinnode = 3
)

pred_ts <- predict(gbm_ts, newdata = test_ts, n.trees = 1500)
rmse_ts <- sqrt(mean((test_ts$y - pred_ts)^2))
rmse_ts

#> [1] 60.59657

7.8 Tugas

Bangun model gradient boosting pada dataset regresi pilihan Anda.
Ubah satu dataset time series menjadi format supervised dengan minimal dua lag.
Bandingkan gradient boosting dengan regresi linear sebagai baseline.

7.9 Kuis Singkat

Mengapa boosting disebut sekuensial?
Apa peran learning rate pada gradient boosting?
Mengapa tree yang dipakai dalam boosting sering berukuran kecil?
Bagaimana cara mengubah time series menjadi masalah supervised?
Apa risiko utama jika jumlah tree terlalu besar?

7.10 Ringkasan

Gradient boosting adalah metode ensemble yang sangat kuat untuk regresi maupun time series berbasis lag. Kuncinya bukan hanya pada algoritma, tetapi pada framing masalah dan tuning parameter.

8 UTS: Project Kelompok 2 Orang

8.1 Tujuan Proyek

UTS dirancang untuk mengukur kemampuan mahasiswa dalam:

merumuskan masalah machine learning dengan benar,
menyiapkan data secara rapi,
memilih model awal yang masuk akal,
menjelaskan proses dan hasil secara akademik.

8.2 Bentuk Proyek

dikerjakan berkelompok, maksimal 2 orang,
memakai data nyata,
boleh mengambil topik bisnis, sosial, kesehatan, pendidikan, lingkungan, atau ekonomi,
minimal membandingkan 2 model.

8.3 Struktur Deliverables

Setiap kelompok wajib menyerahkan:

Proposal singkat masalah dan dataset.
Script R yang rapi dan bisa dijalankan.
Report maksimal 10 sampai 15 halaman.
Slide presentasi.

8.4 Struktur Report yang Disarankan

Judul dan anggota kelompok.
Latar belakang masalah.
Tujuan analisis.
Deskripsi data.
Data cleaning dan exploratory data analysis.
Pemodelan.
Evaluasi model.
Kesimpulan dan keterbatasan.

8.5 Rubrik Penilaian UTS

Komponen	Bobot
Rumusan masalah dan relevansi data	20%
Kualitas praproses dan EDA	20%
Ketepatan model dan pembahasan	25%
Evaluasi dan validasi	20%
Presentasi dan kualitas report	15%

8.6 Checklist Proyek

Masalah jelas dan bisa diukur.
Target didefinisikan dengan benar.
Tidak ada data leakage.
Ada baseline model.
Ada evaluasi yang sesuai.
Hasil dapat dijelaskan.

8.7 Contoh Kerangka Folder

project_uts/
  data/
  scripts/
  figures/
  report/
  slides/

8.8 Tugas Proyek

Ajukan topik dan dataset.
Tulis alasan pemilihan target.
Tentukan minimal dua model yang akan dibandingkan.
Tentukan metrik evaluasi yang akan digunakan.

8.9 Kuis Reflektif

Mengapa data leakage berbahaya?
Mengapa baseline wajib ada?
Apa beda tujuan EDA dan evaluasi model?
Mengapa presentasi hasil penting dalam proyek machine learning?
Apa indikator bahwa proyek Anda sudah reprodusibel?

8.10 Ringkasan

UTS tidak hanya menguji kemampuan menjalankan algoritma, tetapi juga ketajaman berpikir analitis, kerapian workflow, dan kemampuan menjelaskan keputusan modeling.

9 Supervised Learning I: Naive Bayes dan K-NN

9.1 Tujuan Pembelajaran

Setelah mempelajari bab ini, pembaca mampu:

Menjelaskan teorema Bayes dan asumsi independensi bersyarat.
Memahami klasifikasi berbasis tetangga terdekat.
Menjelaskan kapan Naive Bayes dan K-NN cocok digunakan.
Mengimplementasikan keduanya di R.

9.2 Naive Bayes

Naive Bayes didasarkan pada:

\[ P(y \mid x_1, \ldots, x_p) \propto P(y)\prod_{j=1}^{p}P(x_j \mid y) \]

Asumsi “naive”-nya adalah fitur saling independen bersyarat terhadap kelas. Asumsi ini sering tidak sepenuhnya benar, tetapi model tetap bisa bekerja baik.

Untuk Gaussian Naive Bayes:

\[ x_j \mid y = c \sim \mathcal{N}(\mu_{jc}, \sigma_{jc}^2) \]

9.3 K-Nearest Neighbors

K-NN mengklasifikasikan observasi baru berdasarkan mayoritas kelas dari \(k\) tetangga terdekat.

Jika \(N_k(x)\) adalah himpunan tetangga terdekat, maka prediksi kelas:

\[ \hat{y}(x) = \arg\max_{c} \sum_{i \in N_k(x)} I(y_i = c) \]

K-NN tidak membangun model parametrik eksplisit. Ia menyimpan data latih dan melakukan prediksi saat diperlukan.

9.4 Kelebihan dan Kekurangan

9.4.1 Naive Bayes

Kelebihan:

cepat,
sederhana,
efektif pada data dimensi tinggi seperti teks.

Kekurangan:

asumsi independensi sering terlalu kuat.

9.4.2 K-NN

Kelebihan:

intuitif,
non-parametrik,
dapat menangkap boundary non-linear.

Kekurangan:

sensitif pada skala fitur,
mahal saat prediksi jika data besar,
pemilihan \(k\) penting.

9.5 Contoh R: Naive Bayes

library(e1071)

set.seed(123)
idx <- sample(seq_len(nrow(iris)), size = 0.7 * nrow(iris))
train <- iris[idx, ]
test  <- iris[-idx, ]

nb_fit <- naiveBayes(Species ~ ., data = train)
nb_pred <- predict(nb_fit, newdata = test)

table(Prediksi = nb_pred, Aktual = test$Species)

#>             Aktual
#> Prediksi     setosa versicolor virginica
#>   setosa         14          0         0
#>   versicolor      0         18         0
#>   virginica       0          0        13

mean(nb_pred == test$Species)

#> [1] 1

9.6 Contoh R: K-NN

library(class)

train_x <- scale(train[, -5])
test_x  <- scale(
  test[, -5],
  center = attr(train_x, "scaled:center"),
  scale = attr(train_x, "scaled:scale")
)

knn_pred <- knn(
  train = train_x,
  test = test_x,
  cl = train$Species,
  k = 5
)

table(Prediksi = knn_pred, Aktual = test$Species)

#>             Aktual
#> Prediksi     setosa versicolor virginica
#>   setosa         14          0         0
#>   versicolor      0         17         0
#>   virginica       0          1        13

mean(knn_pred == test$Species)

#> [1] 0.9777778

9.7 Tugas

Bandingkan Naive Bayes dan K-NN pada iris.
Uji beberapa nilai k pada K-NN dan amati perubahan akurasi.
Jelaskan mengapa standardisasi diperlukan pada K-NN tetapi tidak selalu pada Naive Bayes.

9.8 Kuis Singkat

Apa asumsi utama Naive Bayes?
Mengapa K-NN disebut lazy learner?
Apa dampak nilai k yang terlalu kecil?
Mengapa skala fitur memengaruhi K-NN?
Kapan Naive Bayes sering unggul?

9.9 Ringkasan

Naive Bayes unggul karena kesederhanaan dan kecepatan, sedangkan K-NN unggul karena fleksibilitas non-parametrik. Keduanya adalah pintu masuk yang baik untuk memahami klasifikasi.

10 Supervised Learning II: Decision Tree

10.1 Tujuan Pembelajaran

Pembaca mampu:

Menjelaskan struktur pohon keputusan.
Menuliskan kriteria split untuk klasifikasi dan regresi.
Memahami pruning.
Mengimplementasikan decision tree di R.
Menjelaskan alur algoritma CART dari awal sampai akhir.
Menghitung impurity sederhana secara manual.
Membedakan pre-pruning dan post-pruning.
Menjelaskan kelebihan, keterbatasan, dan kasus penggunaan decision tree.

10.2 Mengapa Decision Tree Penting?

Decision tree adalah salah satu algoritma paling penting dalam machine learning karena tiga alasan.

Pertama, decision tree sangat mudah dijelaskan.

Kedua, decision tree mampu menangkap hubungan non-linear tanpa perlu transformasi yang rumit.

Ketiga, decision tree menjadi fondasi langsung bagi banyak metode ensemble modern seperti bagging, Random Forest, AdaBoost, dan Gradient Boosting.

Jika regresi linear adalah pintu masuk ke supervised learning dari sisi model parametrik, maka decision tree adalah pintu masuk ke supervised learning dari sisi model berbasis aturan.

10.3 Intuisi Decision Tree

Bayangkan kita ingin memutuskan apakah seorang nasabah berisiko gagal bayar.

Alih-alih membuat persamaan linear, decision tree membuat aturan seperti:

jika pendapatan < 5 juta dan utang > 10 juta, maka risiko tinggi,
jika pendapatan >= 5 juta dan riwayat kredit baik, maka risiko rendah.

Aturan ini disusun dalam struktur pohon.

Setiap node internal memuat pertanyaan.

Setiap cabang memuat hasil dari pertanyaan itu.

Setiap daun memuat prediksi akhir.

Karena itu, decision tree sangat dekat dengan cara manusia mengambil keputusan bertahap.

10.4 Struktur Dasar Decision Tree

Komponen utama decision tree adalah:

root node,
internal node,
branch,
terminal node atau leaf.

10.4.1 Root Node

Root node adalah simpul pertama yang memecah data.

Biasanya root node memuat split yang paling informatif.

10.4.2 Internal Node

Internal node adalah simpul di tengah pohon yang masih melakukan pemisahan data.

Contoh:

Petal.Length < 2.45
wt < 2.5
Age >= 40

10.4.3 Branch

Branch adalah hasil dari aturan pemisahan.

Misalnya:

ya,
tidak,
kurang dari threshold,
lebih besar atau sama dengan threshold.

10.4.4 Leaf Node

Leaf node adalah simpul akhir yang tidak dipecah lagi.

Untuk klasifikasi, leaf node berisi kelas mayoritas atau probabilitas kelas.

Untuk regresi, leaf node berisi rata-rata target pada region tersebut.

10.5 Decision Tree sebagai Partisi Ruang Fitur

Secara geometris, decision tree membagi ruang fitur menjadi beberapa region berbentuk persegi panjang atau hyper-rectangle.

Jika kita punya dua fitur, misalnya x1 dan x2, maka setiap split membuat garis vertikal atau horizontal.

Gabungan banyak split membentuk potongan-potongan area.

Setiap area memiliki satu prediksi.

Dalam klasifikasi:

\[ \hat{y}(x) = c_m \quad \text{jika } x \in R_m \]

Dalam regresi:

\[ \hat{y}(x) = \bar{y}_{R_m} \quad \text{jika } x \in R_m \]

dengan \(R_m\) adalah region ke-\(m\).

10.6 Klasifikasi vs Regresi pada Decision Tree

Decision tree dapat dipakai untuk dua jenis masalah utama.

10.6.1 Tree untuk Klasifikasi

Target berupa kategori, misalnya:

lulus atau tidak,
sakit atau tidak,
spesies bunga,
fraud atau non-fraud.

Tree klasifikasi memilih split yang paling menurunkan impurity kelas.

10.6.2 Tree untuk Regresi

Target berupa nilai kontinu, misalnya:

harga,
pendapatan,
suhu,
jumlah penjualan.

Tree regresi memilih split yang paling menurunkan galat prediksi dalam node.

10.7 Logika Utama Pembentukan Pohon

Prinsip dasarnya sangat sederhana:

mulai dari seluruh data dalam satu node,
cari split terbaik dari semua fitur yang tersedia,
pecah data sesuai split tersebut,
ulangi proses pada setiap node baru,
hentikan jika node sudah cukup homogen atau batas kompleksitas tercapai.

Meski sederhana, proses ini menghasilkan model yang sangat fleksibel.

10.8 Kriteria Split untuk Klasifikasi

Pada klasifikasi, kita perlu mengukur “seberapa campur” kelas dalam sebuah node.

Ukuran ketidakmurnian ini disebut impurity.

Semakin homogen node, semakin kecil impurity.

Semakin campur node, semakin besar impurity.

Ukuran yang umum dipakai adalah:

entropy,
information gain,
Gini index,
misclassification error.

10.8.1 Entropy

Entropy mengukur ketidakpastian distribusi kelas:

\[ H(S) = - \sum_{c=1}^{C} p_c \log_2 p_c \]

dengan:

\(C\) adalah jumlah kelas,
\(p_c\) adalah proporsi kelas ke-\(c\) dalam node \(S\).

Karakter entropy:

bernilai 0 jika node murni,
maksimum jika distribusi kelas merata.

Untuk dua kelas:

jika semua observasi berasal dari satu kelas, entropy = 0,
jika proporsi 50:50, entropy = 1.

10.8.2 Information Gain

Information gain mengukur penurunan entropy setelah split.

\[ \text{Gain}(S, A) = H(S) - \sum_{v \in Values(A)} \frac{|S_v|}{|S|} H(S_v) \]

dengan:

\(A\) adalah atribut atau split candidate,
\(S_v\) adalah subset setelah split.

Split terbaik adalah split dengan information gain terbesar.

10.8.3 Gini Index

Gini index adalah ukuran impurity yang sangat populer pada algoritma CART:

\[ G(S) = 1 - \sum_{c=1}^{C} p_c^2 \]

Interpretasinya:

Gini = 0 jika node murni,
makin besar Gini, makin campur node tersebut.

Untuk klasifikasi dua kelas dengan proporsi \(p\) dan \(1-p\):

\[ G(S) = 2p(1-p) \]

Nilai maksimum terjadi saat \(p = 0.5\).

10.8.4 Misclassification Error

Ukuran ini lebih sederhana:

\[ E(S) = 1 - \max_c p_c \]

Nilai ini sering dipakai untuk evaluasi node, tetapi tidak sepeka entropy dan Gini dalam proses split.

10.9 Perbandingan Entropy, Gini, dan Misclassification Error

Ukuran	Rumus	Sensitivitas	Umum dipakai pada
Entropy	\(-\sum p_c \log_2 p_c\)	tinggi	ID3, C4.5
Gini	\(1 - \sum p_c^2\)	tinggi	CART
Misclassification error	\(1 - \max p_c\)	lebih rendah	pruning, evaluasi

Secara praktik:

entropy dan Gini sering memberi hasil mirip,
Gini lebih murah secara komputasi,
misclassification error kurang sensitif untuk split awal.

10.10 Contoh Perhitungan Manual Impurity

Misalkan sebuah node berisi 10 observasi:

6 kelas Ya,
4 kelas Tidak.

Maka:

\[ p_{Ya} = 0.6, \quad p_{Tidak} = 0.4 \]

10.10.1 Entropy Node Awal

\[ H(S) = -(0.6 \log_2 0.6 + 0.4 \log_2 0.4) \]

\[ H(S) \approx -(0.6 \times -0.737 + 0.4 \times -1.322) \]

\[ H(S) \approx 0.971 \]

10.10.2 Gini Node Awal

\[ G(S) = 1 - (0.6^2 + 0.4^2) \]

\[ G(S) = 1 - (0.36 + 0.16) = 0.48 \]

10.10.3 Misclassification Error

\[ E(S) = 1 - \max(0.6, 0.4) = 0.4 \]

10.11 Contoh Split Manual

Misalkan split Pendapatan < 5 membagi node menjadi dua anak:

Node kiri:

4 Ya,
1 Tidak

Node kanan:

2 Ya,
3 Tidak

10.11.1 Entropy Anak Kiri

\[ H(S_L) = -(0.8\log_2 0.8 + 0.2\log_2 0.2) \approx 0.722 \]

10.11.2 Entropy Anak Kanan

\[ H(S_R) = -(0.4\log_2 0.4 + 0.6\log_2 0.6) \approx 0.971 \]

Karena masing-masing node berisi 5 observasi, maka weighted entropy sesudah split:

\[ H_{after} = \frac{5}{10}(0.722) + \frac{5}{10}(0.971) = 0.8465 \]

Information gain:

\[ \text{Gain} = 0.971 - 0.8465 = 0.1245 \]

Jika split lain memberi gain yang lebih besar, maka split itu akan dipilih.

10.12 Kriteria Split untuk Regresi

Pada regresi, target split umumnya meminimalkan residual sum of squares:

\[ \sum_{i \in R_1}(y_i - \bar{y}_{R_1})^2 + \sum_{i \in R_2}(y_i - \bar{y}_{R_2})^2 \]

atau secara umum:

\[ \text{RSS}_{split} = \sum_{m=1}^{M} \sum_{i \in R_m} (y_i - \bar{y}_{R_m})^2 \]

Tree akan memilih split yang menurunkan RSS paling besar.

10.12.1 Mengapa Mean Dipakai pada Leaf?

Untuk squared error loss, prediksi konstan terbaik dalam satu region adalah rata-rata.

Secara formal, jika kita ingin memilih konstanta \(c\) yang meminimalkan:

\[ \sum_{i \in R}(y_i - c)^2 \]

maka solusi optimalnya adalah:

\[ c = \bar{y}_R \]

Itu sebabnya leaf pada regression tree biasanya berisi mean target.

10.13 CART: Classification and Regression Trees

Algoritma decision tree yang paling terkenal adalah CART.

Karakter CART:

menghasilkan binary split,
bisa dipakai untuk klasifikasi dan regresi,
umumnya memakai Gini untuk klasifikasi,
memakai RSS untuk regresi,
mendukung pruning melalui cost complexity pruning.

10.14 Langkah-Langkah Algoritma CART

10.14.1 Langkah 1: Mulai dari Root

Semua data diletakkan pada satu node.

10.14.2 Langkah 2: Evaluasi Semua Split Kandidat

Untuk setiap fitur:

jika numerik, uji berbagai threshold,
jika kategorik, uji pemisahan kategori yang mungkin.

10.14.3 Langkah 3: Pilih Split Terbaik

Split terbaik adalah yang paling menurunkan impurity atau RSS.

10.14.4 Langkah 4: Bagi Data ke Anak Kiri dan Kanan

Node dipecah menjadi dua subset.

10.14.5 Langkah 5: Ulangi Rekursif

Untuk setiap node baru, proses diulang sampai kriteria berhenti dipenuhi.

10.14.6 Langkah 6: Pruning

Setelah pohon besar terbentuk, kita sederhanakan pohon agar generalisasi lebih baik.

10.15 Kapan Proses Splitting Dihentikan?

Pertumbuhan pohon tidak boleh dibiarkan tanpa batas.

Beberapa aturan penghentian umum:

jumlah observasi di node terlalu sedikit,
node sudah murni,
impurity reduction sangat kecil,
depth maksimum tercapai,
nilai complexity parameter tercapai.

10.16 Hyperparameter Penting pada Decision Tree

Dalam praktik, perilaku pohon banyak dipengaruhi hyperparameter.

Beberapa yang paling penting:

maxdepth,
minsplit,
minbucket,
cp,
maxcompete,
usesurrogate.

10.16.1 `maxdepth`

Mengontrol kedalaman maksimum pohon.

Pohon yang terlalu dalam:

fleksibel,
tapi rawan overfitting.

10.16.2 `minsplit`

Jumlah minimum observasi dalam node agar node itu boleh di-split.

10.16.3 `minbucket`

Jumlah minimum observasi dalam leaf.

10.16.4 `cp`

Complexity parameter.

Split baru hanya dipertahankan jika perbaikan model lebih besar dari nilai ini.

Semakin besar cp, semakin sederhana pohon.

10.17 Pre-Pruning dan Post-Pruning

Ada dua cara utama mengendalikan kompleksitas pohon.

10.17.1 Pre-Pruning

Pohon dihentikan lebih awal dengan aturan seperti:

depth maksimum,
minimum observasi,
minimum gain.

Keuntungan pre-pruning:

cepat,
efisien,
mudah diterapkan.

Kelemahannya:

bisa menghentikan pohon terlalu dini,
struktur penting mungkin tidak pernah terbentuk.

10.17.2 Post-Pruning

Langkahnya:

bangun pohon besar dahulu,
potong cabang yang tidak memberi manfaat prediktif memadai.

Keuntungan post-pruning:

lebih fleksibel,
sering menghasilkan pohon akhir yang lebih baik.

Kelemahannya:

komputasi lebih besar,
butuh validasi tambahan.

10.18 Pruning dengan Cost Complexity

Tree yang terlalu dalam rawan overfitting.

Cost complexity pruning meminimalkan:

\[ R_\alpha(T) = R(T) + \alpha |T| \]

dengan:

\(R(T)\): error pohon,
\(|T|\): jumlah terminal nodes,
\(\alpha\): penalti kompleksitas.

Interpretasi:

jika \(\alpha\) kecil, model mengizinkan pohon yang lebih besar,
jika \(\alpha\) besar, model memilih pohon yang lebih kecil.

Dalam rpart, ide ini direpresentasikan lewat cp.

10.19 Underfitting vs Overfitting pada Tree

10.19.1 Pohon Terlalu Dangkal

Jika pohon terlalu dangkal:

aturan terlalu sederhana,
pola penting tidak tertangkap,
bias tinggi.

10.19.2 Pohon Terlalu Dalam

Jika pohon terlalu dalam:

model menyesuaikan noise data latih,
prediksi data baru memburuk,
variance tinggi.

10.19.3 Pohon yang Baik

Pohon yang baik:

cukup dalam untuk menangkap struktur,
cukup sederhana untuk stabil,
dapat dijelaskan,
lolos evaluasi out-of-sample.

10.20 Decision Boundary

Decision tree menciptakan boundary berbentuk potongan-potongan ortogonal.

Ini berarti:

tree bagus untuk pola yang bisa dipecah bertahap,
tree kurang mulus dibanding model seperti SVM radial,
tetapi tree sangat mudah diterjemahkan menjadi aturan.

10.21 Kelebihan Decision Tree

Sangat interpretatif.
Tidak butuh standardisasi fitur.
Bisa menangani fitur numerik dan kategorik.
Menangkap interaksi otomatis.
Dapat memodelkan non-linearitas.
Dapat divisualisasikan dengan jelas.

10.22 Keterbatasan Decision Tree

Rawan overfitting.
Perubahan kecil pada data bisa menghasilkan pohon berbeda.
Boundary cenderung kotak-kotak.
Pada data kecil, performa bisa tidak stabil.
Single tree sering kalah akurasi dari ensemble.

10.23 Kapan Decision Tree Sangat Cocok?

Decision tree cocok ketika:

interpretasi lebih penting daripada akurasi maksimum,
aturan keputusan perlu dijelaskan ke manajemen,
hubungan data diduga non-linear,
variabel campuran numerik dan kategorik,
kita butuh baseline yang mudah dipahami.

10.24 Kapan Decision Tree Kurang Cocok?

Decision tree kurang ideal ketika:

data sangat kecil dan noisy,
target sangat halus dan kontinu,
stabilitas model sangat penting,
performa prediksi maksimum adalah tujuan utama.

10.25 Decision Tree dan Feature Engineering

Decision tree relatif ringan kebutuhan feature engineering-nya.

Misalnya, tree tidak membutuhkan:

standardisasi,
transformasi polynomial eksplisit,
dummy interaction manual dalam banyak kasus.

Tetapi, tree tetap diuntungkan oleh:

penanganan missing values,
penghapusan noise ekstrem,
encoding kategori yang benar,
penggabungan kategori langka bila perlu.

10.26 Penanganan Variabel Numerik

Untuk fitur numerik, tree mencari threshold terbaik:

\[ x_j < s \]

dengan \(s\) adalah kandidat split.

Threshold biasanya dicari dari titik tengah nilai terurut.

10.27 Penanganan Variabel Kategorik

Untuk fitur kategorik, split dapat berbentuk:

kategori A, B masuk kiri,
kategori C, D masuk kanan.

Pada data dengan kategori sangat banyak, jumlah kemungkinan split bisa besar, sehingga perlu strategi komputasional yang efisien.

10.28 Missing Values pada Decision Tree

Beberapa implementasi tree dapat menangani missing values melalui surrogate splits.

Ide surrogate split:

jika fitur utama pada sebuah split hilang,
gunakan split lain yang perilakunya paling mirip.

Ini salah satu keunggulan tree dibanding model yang sangat sensitif pada missing values.

10.29 Decision Tree dan Class Imbalance

Pada data tidak seimbang, tree bisa cenderung memilih kelas mayoritas.

Strategi penanganan:

class weights,
resampling,
threshold adjustment,
evaluasi dengan precision, recall, F1, atau balanced accuracy.

10.30 Variable Importance pada Decision Tree

Decision tree dapat memberi gambaran fitur mana yang paling sering dan paling berguna dalam split.

Secara intuitif, fitur yang:

sering muncul di node atas,
menurunkan impurity besar,

dianggap lebih penting.

Namun, variable importance pada single tree harus dibaca hati-hati karena pohon tunggal tidak stabil.

10.31 Rule Extraction

Salah satu kekuatan tree adalah aturan keputusan dapat diekstrak langsung.

Contoh aturan:

jika Petal.Length < 2.45, maka setosa,
jika Petal.Length >= 2.45 dan Petal.Width < 1.75, maka versicolor,
jika Petal.Length >= 2.45 dan Petal.Width >= 1.75, maka virginica.

Aturan seperti ini sangat kuat dalam konteks presentasi ke audiens non-teknis.

10.32 Contoh Manual Sederhana dengan Data Kecil

Misalkan kita punya data berikut untuk klasifikasi kelulusan interview.

Kandidat	Pengalaman	TesTeknis	Lulus
1	1	55	Tidak
2	2	60	Tidak
3	2	72	Ya
4	3	75	Ya
5	4	80	Ya
6	1	50	Tidak
7	5	90	Ya
8	3	65	Ya

Secara intuitif, split awal yang mungkin kuat adalah TesTeknis < 66.

Node kiri:

Kandidat 1,
Kandidat 2,
Kandidat 6,
mungkin Kandidat 8 jika threshold berbeda.

Jika threshold dipilih tepat, node kiri dapat menjadi dominan Tidak.

Node kanan dapat menjadi dominan Ya.

Ini menunjukkan bagaimana split threshold sederhana dapat memberi pemisahan yang kuat.

10.33 Contoh Hitung Gini Secara Manual

Misal sebelum split:

5 Ya,
3 Tidak.

Maka:

\[ G_{awal} = 1 - \left(\frac{5}{8}\right)^2 - \left(\frac{3}{8}\right)^2 \]

\[ G_{awal} = 1 - \frac{25}{64} - \frac{9}{64} = \frac{30}{64} = 0.46875 \]

Setelah split:

Node kiri:

1 Ya,
3 Tidak

Node kanan:

4 Ya,
0 Tidak

Gini node kiri:

\[ G_L = 1 - \left(\frac{1}{4}\right)^2 - \left(\frac{3}{4}\right)^2 = 1 - \frac{1}{16} - \frac{9}{16} = \frac{6}{16} = 0.375 \]

Gini node kanan:

\[ G_R = 1 - 1^2 - 0^2 = 0 \]

Weighted Gini:

\[ G_{split} = \frac{4}{8}(0.375) + \frac{4}{8}(0) = 0.1875 \]

Karena \(0.1875 < 0.46875\), split ini jauh lebih baik daripada kondisi awal.

10.34 Decision Tree untuk Regresi: Ilustrasi Konseptual

Misalkan kita ingin memprediksi harga rumah.

Tree bisa membangun aturan:

jika luas < 80 m2, prediksi 350 juta,
jika luas >= 80 m2 dan lokasi = pusat kota, prediksi 950 juta,
jika luas >= 80 m2 dan lokasi != pusat kota, prediksi 700 juta.

Model ini tidak memberi satu persamaan global.

Sebaliknya, model membagi data ke region-region lokal dengan prediksi konstan.

10.35 Formulasi Region pada Regression Tree

Anggap kita membagi ruang fitur menjadi \(M\) region:

\[ R_1, R_2, \ldots, R_M \]

Prediksi:

\[ \hat{f}(x) = \sum_{m=1}^{M} c_m I(x \in R_m) \]

dengan \(c_m = \bar{y}_{R_m}\).

Tujuan tree adalah mencari:

region \(R_m\),
dan konstanta \(c_m\),

yang meminimalkan total RSS.

10.36 Hubungan Tree dengan Interaksi Antarvariabel

Decision tree secara alami memodelkan interaksi.

Contoh:

split pertama pada Pendapatan,
split berikutnya pada Usia,
split ketiga pada Jumlah Anak.

Ini secara implisit berarti pengaruh Usia bisa berbeda tergantung Pendapatan.

Pada model linear, interaksi seperti ini biasanya harus ditulis eksplisit.

10.37 Hubungan Tree dengan Non-Linearitas

Tree tidak mengasumsikan hubungan linear.

Jika hubungan antara x dan y melengkung, tree tetap bisa mendekatinya dengan partisi bertingkat.

Kekurangannya, aproksimasi menjadi bertangga atau piecewise constant.

10.38 Decision Tree vs Regresi Linear

Aspek	Regresi Linear	Decision Tree
Bentuk model	persamaan global	aturan lokal bertingkat
Asumsi linearitas	ya	tidak
Interpretasi koefisien	jelas	tidak ada koefisien global
Interpretasi aturan	tidak langsung	sangat jelas
Stabilitas	lebih stabil	lebih sensitif pada data
Interaksi	harus ditentukan	otomatis

10.39 Decision Tree vs K-NN

Aspek	Decision Tree	K-NN
Tipe model	rule-based	instance-based
Interpretasi	tinggi	rendah
Prediksi cepat	ya	relatif lebih lambat
Standardisasi perlu	tidak wajib	sangat penting
Bentuk boundary	ortogonal	sangat fleksibel

10.40 Decision Tree vs Random Forest

Aspek	Decision Tree	Random Forest
Jumlah pohon	satu	banyak
Interpretasi	sangat tinggi	lebih rendah
Stabilitas	rendah sampai sedang	tinggi
Akurasi	sedang	sering lebih tinggi
Variance	tinggi	lebih rendah

10.41 Metrik Evaluasi untuk Tree Klasifikasi

Beberapa metrik yang relevan:

accuracy,
precision,
recall,
F1-score,
ROC-AUC,
balanced accuracy.

Untuk dataset seimbang, accuracy sering cukup.

Untuk dataset tidak seimbang, perlu metrik yang lebih sensitif pada kelas minoritas.

10.42 Metrik Evaluasi untuk Tree Regresi

Gunakan:

MAE,
RMSE,
\(R^2\),
MAPE jika relevan.

10.43 Contoh R: Decision Tree Klasifikasi Dasar

library(rpart)
library(rpart.plot)

tree_cls <- rpart(
  Species ~ .,
  data = iris,
  method = "class",
  cp = 0.01
)

print(tree_cls)

#> n= 150 
#> 
#> node), split, n, loss, yval, (yprob)
#>       * denotes terminal node
#> 
#> 1) root 150 100 setosa (0.33333333 0.33333333 0.33333333)  
#>   2) Petal.Length< 2.45 50   0 setosa (1.00000000 0.00000000 0.00000000) *
#>   3) Petal.Length>=2.45 100  50 versicolor (0.00000000 0.50000000 0.50000000)  
#>     6) Petal.Width< 1.75 54   5 versicolor (0.00000000 0.90740741 0.09259259) *
#>     7) Petal.Width>=1.75 46   1 virginica (0.00000000 0.02173913 0.97826087) *

summary(tree_cls)

#> Call:
#> rpart(formula = Species ~ ., data = iris, method = "class", cp = 0.01)
#>   n= 150 
#> 
#>     CP nsplit rel error xerror       xstd
#> 1 0.50      0      1.00   1.16 0.05127703
#> 2 0.44      1      0.50   0.69 0.06104097
#> 3 0.01      2      0.06   0.10 0.03055050
#> 
#> Variable importance
#>  Petal.Width Petal.Length Sepal.Length  Sepal.Width 
#>           34           31           21           14 
#> 
#> Node number 1: 150 observations,    complexity param=0.5
#>   predicted class=setosa      expected loss=0.6666667  P(node) =1
#>     class counts:    50    50    50
#>    probabilities: 0.333 0.333 0.333 
#>   left son=2 (50 obs) right son=3 (100 obs)
#>   Primary splits:
#>       Petal.Length < 2.45 to the left,  improve=50.00000, (0 missing)
#>       Petal.Width  < 0.8  to the left,  improve=50.00000, (0 missing)
#>       Sepal.Length < 5.45 to the left,  improve=34.16405, (0 missing)
#>       Sepal.Width  < 3.35 to the right, improve=19.03851, (0 missing)
#>   Surrogate splits:
#>       Petal.Width  < 0.8  to the left,  agree=1.000, adj=1.00, (0 split)
#>       Sepal.Length < 5.45 to the left,  agree=0.920, adj=0.76, (0 split)
#>       Sepal.Width  < 3.35 to the right, agree=0.833, adj=0.50, (0 split)
#> 
#> Node number 2: 50 observations
#>   predicted class=setosa      expected loss=0  P(node) =0.3333333
#>     class counts:    50     0     0
#>    probabilities: 1.000 0.000 0.000 
#> 
#> Node number 3: 100 observations,    complexity param=0.44
#>   predicted class=versicolor  expected loss=0.5  P(node) =0.6666667
#>     class counts:     0    50    50
#>    probabilities: 0.000 0.500 0.500 
#>   left son=6 (54 obs) right son=7 (46 obs)
#>   Primary splits:
#>       Petal.Width  < 1.75 to the left,  improve=38.969400, (0 missing)
#>       Petal.Length < 4.75 to the left,  improve=37.353540, (0 missing)
#>       Sepal.Length < 6.15 to the left,  improve=10.686870, (0 missing)
#>       Sepal.Width  < 2.45 to the left,  improve= 3.555556, (0 missing)
#>   Surrogate splits:
#>       Petal.Length < 4.75 to the left,  agree=0.91, adj=0.804, (0 split)
#>       Sepal.Length < 6.15 to the left,  agree=0.73, adj=0.413, (0 split)
#>       Sepal.Width  < 2.95 to the left,  agree=0.67, adj=0.283, (0 split)
#> 
#> Node number 6: 54 observations
#>   predicted class=versicolor  expected loss=0.09259259  P(node) =0.36
#>     class counts:     0    49     5
#>    probabilities: 0.000 0.907 0.093 
#> 
#> Node number 7: 46 observations
#>   predicted class=virginica   expected loss=0.02173913  P(node) =0.3066667
#>     class counts:     0     1    45
#>    probabilities: 0.000 0.022 0.978

rpart.plot(tree_cls, type = 2, extra = 104, fallen.leaves = TRUE)

10.44 Penjelasan Kode

method = "class" berarti target adalah kategori.
cp = 0.01 memberi penalti kompleksitas awal.
extra = 104 pada rpart.plot() menampilkan informasi kelas dan probabilitas.

10.45 Contoh R: Melihat Tabel Complexity Parameter

printcp(tree_cls)

#> 
#> Classification tree:
#> rpart(formula = Species ~ ., data = iris, method = "class", cp = 0.01)
#> 
#> Variables actually used in tree construction:
#> [1] Petal.Length Petal.Width 
#> 
#> Root node error: 100/150 = 0.66667
#> 
#> n= 150 
#> 
#>     CP nsplit rel error xerror     xstd
#> 1 0.50      0      1.00   1.16 0.051277
#> 2 0.44      1      0.50   0.69 0.061041
#> 3 0.01      2      0.06   0.10 0.030551

plotcp(tree_cls)

Tabel cptable sangat penting karena memuat:

jumlah split,
relative error,
cross-validated error,
standard error.

Nilai xerror minimum sering dipakai untuk memilih ukuran pohon terbaik.

10.46 Contoh R: Pruning Tree Klasifikasi

best_cp <- tree_cls$cptable[
  which.min(tree_cls$cptable[, "xerror"]),
  "CP"
]

pruned_cls <- prune(tree_cls, cp = best_cp)

printcp(pruned_cls)

#> 
#> Classification tree:
#> rpart(formula = Species ~ ., data = iris, method = "class", cp = 0.01)
#> 
#> Variables actually used in tree construction:
#> [1] Petal.Length Petal.Width 
#> 
#> Root node error: 100/150 = 0.66667
#> 
#> n= 150 
#> 
#>     CP nsplit rel error xerror     xstd
#> 1 0.50      0      1.00   1.16 0.051277
#> 2 0.44      1      0.50   0.69 0.061041
#> 3 0.01      2      0.06   0.10 0.030551

rpart.plot(pruned_cls, type = 2, extra = 104, fallen.leaves = TRUE)

10.47 Mengapa Pruning Penting?

Pohon awal sering tumbuh terlalu detail.

Pruning:

mengurangi noise,
membuat aturan lebih ringkas,
meningkatkan generalisasi,
memperjelas interpretasi.

10.48 Contoh R: Prediksi dan Confusion Matrix

set.seed(123)
idx_tree <- sample(seq_len(nrow(iris)), size = 0.7 * nrow(iris))
train_tree <- iris[idx_tree, ]
test_tree  <- iris[-idx_tree, ]

fit_tree <- rpart(Species ~ ., data = train_tree, method = "class")
pred_tree <- predict(fit_tree, newdata = test_tree, type = "class")
prob_tree <- predict(fit_tree, newdata = test_tree, type = "prob")

table(Prediksi = pred_tree, Aktual = test_tree$Species)

#>             Aktual
#> Prediksi     setosa versicolor virginica
#>   setosa         14          0         0
#>   versicolor      0         18         1
#>   virginica       0          0        12

head(prob_tree)

#>    setosa versicolor virginica
#> 1       1          0         0
#> 2       1          0         0
#> 3       1          0         0
#> 5       1          0         0
#> 11      1          0         0
#> 18      1          0         0

mean(pred_tree == test_tree$Species)

#> [1] 0.9777778

10.49 Contoh R: Decision Tree Regresi

tree_reg <- rpart(
  mpg ~ wt + hp + disp + cyl,
  data = mtcars,
  method = "anova",
  cp = 0.01
)

print(tree_reg)

#> n= 32 
#> 
#> node), split, n, deviance, yval
#>       * denotes terminal node
#> 
#> 1) root 32 1126.04700 20.09062  
#>   2) cyl>=5 21  198.47240 16.64762  
#>     4) hp>=192.5 7   28.82857 13.41429 *
#>     5) hp< 192.5 14   59.87214 18.26429 *
#>   3) cyl< 5 11  203.38550 26.66364 *

summary(tree_reg)

#> Call:
#> rpart(formula = mpg ~ wt + hp + disp + cyl, data = mtcars, method = "anova", 
#>     cp = 0.01)
#>   n= 32 
#> 
#>           CP nsplit rel error    xerror      xstd
#> 1 0.64312523      0 1.0000000 1.0695014 0.2527134
#> 2 0.09748407      1 0.3568748 0.5921302 0.1637366
#> 3 0.01000000      2 0.2593907 0.4925836 0.1123262
#> 
#> Variable importance
#>  cyl disp   hp   wt 
#>   27   26   26   21 
#> 
#> Node number 1: 32 observations,    complexity param=0.6431252
#>   mean=20.09062, MSE=35.18897 
#>   left son=2 (21 obs) right son=3 (11 obs)
#>   Primary splits:
#>       cyl  < 5      to the right, improve=0.6431252, (0 missing)
#>       wt   < 2.3925 to the right, improve=0.6356630, (0 missing)
#>       disp < 163.8  to the right, improve=0.6130502, (0 missing)
#>       hp   < 118    to the right, improve=0.6010712, (0 missing)
#>   Surrogate splits:
#>       disp < 142.9  to the right, agree=0.969, adj=0.909, (0 split)
#>       hp   < 101    to the right, agree=0.938, adj=0.818, (0 split)
#>       wt   < 2.5425 to the right, agree=0.906, adj=0.727, (0 split)
#> 
#> Node number 2: 21 observations,    complexity param=0.09748407
#>   mean=16.64762, MSE=9.451066 
#>   left son=4 (7 obs) right son=5 (14 obs)
#>   Primary splits:
#>       hp   < 192.5  to the right, improve=0.5530828, (0 missing)
#>       disp < 266.9  to the right, improve=0.5068475, (0 missing)
#>       cyl  < 7      to the right, improve=0.5068475, (0 missing)
#>       wt   < 3.49   to the right, improve=0.4414890, (0 missing)
#>   Surrogate splits:
#>       disp < 334    to the right, agree=0.857, adj=0.571, (0 split)
#>       wt   < 4.66   to the right, agree=0.810, adj=0.429, (0 split)
#> 
#> Node number 3: 11 observations
#>   mean=26.66364, MSE=18.48959 
#> 
#> Node number 4: 7 observations
#>   mean=13.41429, MSE=4.118367 
#> 
#> Node number 5: 14 observations
#>   mean=18.26429, MSE=4.276582

rpart.plot(tree_reg, type = 2, extra = 101, fallen.leaves = TRUE)

10.50 Contoh R: Evaluasi Tree Regresi

pred_reg <- predict(tree_reg, newdata = mtcars)
rmse_reg <- sqrt(mean((mtcars$mpg - pred_reg)^2))
mae_reg  <- mean(abs(mtcars$mpg - pred_reg))
r2_reg   <- 1 - sum((mtcars$mpg - pred_reg)^2) /
  sum((mtcars$mpg - mean(mtcars$mpg))^2)

c(RMSE = rmse_reg, MAE = mae_reg, R2 = r2_reg)

#>      RMSE       MAE        R2 
#> 3.0212072 2.4734172 0.7406093

10.51 Contoh R: Membandingkan Pohon Dangkal dan Pohon Dalam

tree_shallow <- rpart(
  Species ~ .,
  data = iris,
  method = "class",
  control = rpart.control(maxdepth = 2, cp = 0.01)
)

tree_deep <- rpart(
  Species ~ .,
  data = iris,
  method = "class",
  control = rpart.control(maxdepth = 10, cp = 0.0001)
)

rpart.plot(tree_shallow, type = 2, extra = 104)

rpart.plot(tree_deep, type = 2, extra = 104)

10.52 Apa yang Perlu Diamati dari Perbandingan Ini?

Amati:

jumlah node,
kompleksitas aturan,
kemungkinan overfitting,
kemudahan interpretasi.

Pohon dangkal:

mudah dijelaskan,
tetapi bisa underfit.

Pohon dalam:

lebih fleksibel,
tetapi bisa tidak stabil.

10.53 Contoh R: Kontrol Hyperparameter

fit_control <- rpart(
  Species ~ .,
  data = iris,
  method = "class",
  control = rpart.control(
    minsplit = 10,
    minbucket = 3,
    maxdepth = 4,
    cp = 0.005
  )
)

printcp(fit_control)

#> 
#> Classification tree:
#> rpart(formula = Species ~ ., data = iris, method = "class", control = rpart.control(minsplit = 10, 
#>     minbucket = 3, maxdepth = 4, cp = 0.005))
#> 
#> Variables actually used in tree construction:
#> [1] Petal.Length Petal.Width 
#> 
#> Root node error: 100/150 = 0.66667
#> 
#> n= 150 
#> 
#>      CP nsplit rel error xerror     xstd
#> 1 0.500      0      1.00   1.14 0.052307
#> 2 0.440      1      0.50   0.59 0.059828
#> 3 0.020      2      0.06   0.10 0.030551
#> 4 0.005      3      0.04   0.07 0.025833

rpart.plot(fit_control, type = 2, extra = 104)

10.54 Contoh R: Ekstraksi Aturan dari Pohon

path.rpart(pruned_cls, nodes = rownames(pruned_cls$frame[pruned_cls$frame$var == "<leaf>", ]))

#> 
#>  node number: 2 
#>    root
#>    Petal.Length< 2.45
#> 
#>  node number: 6 
#>    root
#>    Petal.Length>=2.45
#>    Petal.Width< 1.75
#> 
#>  node number: 7 
#>    root
#>    Petal.Length>=2.45
#>    Petal.Width>=1.75

Perintah ini berguna untuk:

menyalin aturan ke slide,
menjelaskan ke manajemen,
mendokumentasikan model.

10.55 Contoh R: Prediksi Probabilitas Kelas

prob_cls <- predict(pruned_cls, newdata = iris[1:10, ], type = "prob")
prob_cls

#>    setosa versicolor virginica
#> 1       1          0         0
#> 2       1          0         0
#> 3       1          0         0
#> 4       1          0         0
#> 5       1          0         0
#> 6       1          0         0
#> 7       1          0         0
#> 8       1          0         0
#> 9       1          0         0
#> 10      1          0         0

Pada klasifikasi, tree tidak hanya memberi label akhir, tetapi juga estimasi probabilitas per kelas berdasarkan komposisi leaf.

10.56 Contoh R: Studi Kasus Mini pada `iris`

Interpretasi tree iris sering sederhana:

Petal.Length menjadi split awal yang sangat kuat,
setosa mudah dipisahkan,
versicolor dan virginica membutuhkan split lanjutan.

Maknanya:

variabel petal memuat informasi diskriminatif yang jauh lebih kuat dibanding beberapa variabel sepal,
tree membantu menemukan struktur klasifikasi tanpa asumsi distribusi.

10.57 Contoh R: Studi Kasus Mini pada `mtcars`

Pada mtcars, tree regresi sering memakai wt sebagai split awal.

Interpretasinya:

berat mobil adalah prediktor sangat kuat untuk efisiensi bahan bakar,
pengaruh hp, disp, dan cyl dapat muncul pada cabang tertentu,
hubungan ini tidak perlu linear global.

10.58 Membaca Output `summary(tree_cls)`

Output summary() biasanya menampilkan:

variabel yang dipakai,
jumlah split,
distribusi kelas pada node,
loss pada tiap node,
probabilitas kelas.

Mahasiswa sebaiknya belajar membaca output ini, bukan hanya melihat gambar pohon.

10.59 Membaca Plot Pohon

Hal yang harus diperhatikan dari plot:

variabel apa yang muncul paling atas,
threshold split-nya,
berapa banyak observasi pada tiap node,
probabilitas atau kelas mayoritas tiap leaf,
apakah ada cabang yang sangat kecil.

10.60 Cabang Kecil dan Masalah Generalisasi

Jika sebuah leaf hanya berisi sedikit observasi, prediksi pada leaf itu cenderung tidak stabil.

Karena itu, leaf yang terlalu kecil patut dicurigai sebagai gejala overfitting.

10.61 Decision Tree dan Data Noise

Tree sangat responsif terhadap data.

Hal ini menguntungkan karena fleksibel.

Namun, hal ini juga membuat tree sensitif pada noise.

Satu observasi yang ekstrem kadang bisa mengubah struktur split.

10.62 Mengapa Single Tree Tidak Stabil?

Ketidakstabilan single tree terjadi karena:

split dipilih secara greedy,
split awal sangat mempengaruhi seluruh cabang berikutnya,
perubahan kecil di data bisa mengubah split awal.

Inilah salah satu alasan ensemble tree sangat sukses.

10.63 Greedy Algorithm pada Decision Tree

Tree dibangun dengan strategi greedy.

Artinya, pada tiap node, algoritma memilih split terbaik saat itu, bukan menjamin struktur pohon global paling optimal.

Konsekuensinya:

tree cepat dibangun,
tetapi solusi global optimal tidak dijamin.

10.64 Decision Tree Bukan Model Parametrik Global

Tree tidak punya koefisien seperti \(\beta_1\), \(\beta_2\), dan seterusnya.

Karena itu, interpretasi tree bukan berbasis:

besar koefisien,
tanda koefisien,
signifikansi statistik.

Interpretasi tree berbasis:

aturan split,
urutan split,
distribusi data dalam leaf.

10.65 Decision Tree dan Inferensi Kausal

Decision tree adalah model prediktif, bukan alat inferensi kausal utama.

Jika tujuan analisis adalah:

mengukur efek sebab-akibat,
menguji hipotesis kebijakan,

maka tree perlu dipakai sangat hati-hati atau dikombinasikan dengan kerangka kausal lain.

10.66 Decision Tree untuk Segmentasi

Selain prediksi, tree juga berguna untuk segmentasi berbasis aturan.

Contoh:

pelanggan dengan transaksi tinggi dan frekuensi rendah,
mahasiswa dengan kehadiran rendah dan nilai tugas rendah,
pasien dengan umur tinggi dan komorbid tertentu.

Segmentasi seperti ini mudah dikomunikasikan.

10.67 Decision Tree dan Interpretabilitas Kebijakan

Dalam konteks kebijakan publik, decision tree berguna karena:

aturan keputusan mudah dijelaskan,
dapat membantu prioritisasi sasaran,
memudahkan komunikasi lintas tim.

Namun, perlu dijaga agar model tidak menimbulkan keputusan yang tidak adil karena bias data.

10.68 Fairness dan Decision Tree

Karena tree membagi data berdasarkan fitur, fitur sensitif seperti:

gender,
suku,
wilayah,

dapat mempengaruhi aturan keputusan.

Karena itu, penting untuk:

memeriksa bias fitur,
mengevaluasi fairness,
mempertimbangkan dampak etis pemodelan.

10.69 Decision Tree dan Outlier

Tree umumnya lebih tahan terhadap outlier dibanding regresi linear, karena split berbasis threshold, bukan jarak kuadrat global.

Tetapi, outlier tetap bisa mempengaruhi struktur split, terutama jika jumlah data kecil.

10.70 Decision Tree dan Skala Variabel

Tree tidak memerlukan standardisasi.

Mengapa?

Karena tree tidak mengukur jarak Euclidean, melainkan mencari threshold pemisah pada tiap fitur.

Ini berbeda dari:

K-NN,
SVM,
PCA,

yang sangat dipengaruhi skala.

10.71 Decision Tree dan Multikolinearitas

Multikolinearitas bukan masalah utama seperti pada OLS.

Namun, jika ada dua fitur sangat berkorelasi, tree bisa memilih salah satunya secara arbitrer, sehingga interpretasi importance perlu hati-hati.

10.72 Tips Praktis Saat Mengajar Decision Tree

Untuk kelas, decision tree sebaiknya diajarkan dengan urutan:

contoh aturan sehari-hari,
visual pohon,
impurity,
split manual,
implementasi R,
pruning,
hubungan ke Random Forest dan Boosting.

Urutan ini biasanya lebih mudah diterima daripada langsung masuk rumus.

10.73 Checklist Pemodelan Decision Tree

Sebelum membangun model:

cek tipe target,
cek missing values,
tentukan metrik,
siapkan train-test split.

Saat membangun model:

mulai dari tree sederhana,
catat hyperparameter,
lihat cptable,
lakukan pruning.

Setelah model jadi:

evaluasi out-of-sample,
interpretasikan aturan utama,
cek apakah aturan masuk akal secara substantif.

10.74 Kesalahan Umum Mahasiswa

Hanya melihat plot tanpa membaca output evaluasi.
Menganggap pohon paling besar pasti terbaik.
Tidak melakukan pruning.
Mengabaikan test set.
Salah menafsirkan leaf sebagai hubungan kausal.
Mengira tree selalu lebih baik dari semua model lain.

10.75 Studi Kasus Konseptual 1: Klasifikasi Kredit

Misal kita memiliki variabel:

pendapatan,
umur,
status pekerjaan,
rasio utang terhadap pendapatan,
riwayat kredit.

Target:

default atau non-default.

Tree dapat memberi aturan:

jika rasio utang tinggi dan riwayat kredit buruk, maka default,
jika rasio utang rendah dan pekerjaan tetap, maka non-default.

Nilai tambah:

aturan mudah dijelaskan ke bagian kredit,
manajer bisa memahami logika keputusan model.

10.76 Studi Kasus Konseptual 2: Klasifikasi Kelulusan Mahasiswa

Variabel:

kehadiran,
nilai tugas,
nilai UTS,
keterlambatan pengumpulan.

Target:

lulus atau tidak.

Tree mungkin menemukan:

jika kehadiran < 70 persen, risiko tidak lulus tinggi,
jika kehadiran tinggi tetapi nilai tugas rendah, perlu split lanjutan.

10.77 Studi Kasus Konseptual 3: Regresi Harga Rumah

Variabel:

luas bangunan,
jumlah kamar,
lokasi,
usia bangunan.

Target:

harga rumah.

Tree dapat menemukan segmentasi:

rumah kecil di pinggiran,
rumah besar di pusat kota,
rumah tua dengan diskon harga.

10.78 Latihan Interpretasi

Coba jawab pertanyaan berikut jika Anda melihat pohon:

split apa yang paling dominan?
variabel apa yang muncul paling atas?
berapa banyak segmen utama data?
adakah cabang yang tampak terlalu kecil?
apakah aturan pohon logis secara substantif?

10.79 Contoh R: Perbandingan Akurasi Sebelum dan Sesudah Pruning

set.seed(123)
idx_prune <- sample(seq_len(nrow(iris)), size = 0.7 * nrow(iris))
train_prune <- iris[idx_prune, ]
test_prune  <- iris[-idx_prune, ]

tree_full <- rpart(
  Species ~ .,
  data = train_prune,
  method = "class",
  control = rpart.control(cp = 0.0001, minsplit = 2)
)

pred_full <- predict(tree_full, newdata = test_prune, type = "class")
acc_full  <- mean(pred_full == test_prune$Species)

cp_best <- tree_full$cptable[which.min(tree_full$cptable[, "xerror"]), "CP"]
tree_pruned <- prune(tree_full, cp = cp_best)
pred_pruned <- predict(tree_pruned, newdata = test_prune, type = "class")
acc_pruned  <- mean(pred_pruned == test_prune$Species)

c(akurasi_full = acc_full, akurasi_pruned = acc_pruned)

#>   akurasi_full akurasi_pruned 
#>      0.9555556      0.9777778

10.80 Apa yang Biasanya Terjadi?

Sering kali:

akurasi train dari tree penuh lebih tinggi,
tetapi akurasi test tidak selalu lebih baik,
tree pruned lebih ringkas dan kadang lebih generalizable.

10.81 Contoh R: Menyimpan Hasil Prediksi ke Data Frame

hasil_tree <- data.frame(
  aktual = test_prune$Species,
  prediksi = pred_pruned
)

head(hasil_tree)

#>    aktual prediksi
#> 1  setosa   setosa
#> 2  setosa   setosa
#> 3  setosa   setosa
#> 5  setosa   setosa
#> 11 setosa   setosa
#> 18 setosa   setosa

10.82 Contoh R: Tree Regresi dengan Train-Test Split

set.seed(123)
idx_reg <- sample(seq_len(nrow(mtcars)), size = 0.75 * nrow(mtcars))
train_reg_tree <- mtcars[idx_reg, ]
test_reg_tree  <- mtcars[-idx_reg, ]

fit_reg_tree <- rpart(
  mpg ~ wt + hp + disp + cyl + drat,
  data = train_reg_tree,
  method = "anova",
  control = rpart.control(cp = 0.001, minsplit = 5)
)

pred_reg_tree <- predict(fit_reg_tree, newdata = test_reg_tree)
rmse_reg_tree <- sqrt(mean((test_reg_tree$mpg - pred_reg_tree)^2))
rmse_reg_tree

#> [1] 2.394329

10.83 Contoh R: Membandingkan Tree Regresi dengan Regresi Linear

fit_lm_compare <- lm(mpg ~ wt + hp + disp + cyl + drat, data = train_reg_tree)
pred_lm_compare <- predict(fit_lm_compare, newdata = test_reg_tree)

rmse_lm_compare <- sqrt(mean((test_reg_tree$mpg - pred_lm_compare)^2))

c(RMSE_tree = rmse_reg_tree, RMSE_lm = rmse_lm_compare)

#> RMSE_tree   RMSE_lm 
#>  2.394329  2.484322

Latihan interpretasi:

jika RMSE tree lebih rendah, mungkin ada non-linearitas,
jika RMSE linear lebih rendah, mungkin hubungan cukup linear dan data kecil.

10.84 Contoh R: Visualisasi Residual Tree Regresi

res_tree <- test_reg_tree$mpg - pred_reg_tree

plot(
  pred_reg_tree,
  res_tree,
  pch = 19,
  col = "steelblue",
  xlab = "Prediksi",
  ylab = "Residual",
  main = "Residual Plot Decision Tree Regresi"
)
abline(h = 0, lty = 2, col = "red")

10.85 Contoh R: Hyperparameter Tuning Manual Sederhana

grid_cp <- c(0.1, 0.05, 0.01, 0.005, 0.001)
acc_grid <- numeric(length(grid_cp))

for (i in seq_along(grid_cp)) {
  fit_i <- rpart(
    Species ~ .,
    data = train_prune,
    method = "class",
    control = rpart.control(cp = grid_cp[i])
  )

  pred_i <- predict(fit_i, newdata = test_prune, type = "class")
  acc_grid[i] <- mean(pred_i == test_prune$Species)
}

data.frame(cp = grid_cp, accuracy = acc_grid)

#>      cp  accuracy
#> 1 0.100 0.9777778
#> 2 0.050 0.9777778
#> 3 0.010 0.9777778
#> 4 0.005 0.9777778
#> 5 0.001 0.9777778

10.86 Interpretasi Tuning Manual

Tujuan tuning bukan mencari pohon terbesar.

Tujuan tuning adalah mencari kombinasi kompleksitas yang:

cukup akurat,
cukup stabil,
cukup mudah dijelaskan.

10.87 Contoh R: Menghitung Confusion Matrix dari Tree

cm_tree <- table(
  Aktual = test_prune$Species,
  Prediksi = pred_pruned
)

cm_tree

#>             Prediksi
#> Aktual       setosa versicolor virginica
#>   setosa         14          0         0
#>   versicolor      0         17         1
#>   virginica       0          0        13

10.88 Contoh R: Menghitung Accuracy per Kelas Secara Sederhana

diag(cm_tree) / rowSums(cm_tree)

#>     setosa versicolor  virginica 
#>  1.0000000  0.9444444  1.0000000

Ini membantu melihat apakah model:

baik untuk semua kelas,
atau hanya baik pada kelas tertentu.

10.89 Contoh R: Menggunakan `type = "prob"` untuk Analisis Ketidakpastian

prob_test <- predict(tree_pruned, newdata = test_prune, type = "prob")
head(prob_test)

#>    setosa versicolor virginica
#> 1       1          0         0
#> 2       1          0         0
#> 3       1          0         0
#> 5       1          0         0
#> 11      1          0         0
#> 18      1          0         0

Jika probabilitas untuk dua kelas cukup mirip, model sebenarnya kurang yakin.

Informasi ini berguna untuk:

human review,
triase kasus sulit,
threshold adjustment.

10.90 Decision Tree dan Explainability

Explainability adalah kekuatan alami decision tree.

Tree sangat berguna ketika stakeholder ingin tahu:

“mengapa model memberi prediksi ini?”
“aturan apa yang paling penting?”
“kelompok mana yang paling berisiko?”

10.91 Decision Tree dan Communicability

Model yang sangat akurat tetapi tidak bisa dijelaskan kadang sulit diterima organisasi.

Tree memberi kompromi yang baik antara:

kekuatan prediksi,
kemudahan komunikasi.

10.92 Decision Tree dan Monitoring

Setelah model dipakai, pohon juga perlu dimonitor.

Perhatikan:

apakah distribusi data berubah,
apakah split penting masih relevan,
apakah akurasi turun,
apakah kelas target bergeser.

10.93 Decision Tree dan Data Drift

Jika data drift besar, aturan pohon lama bisa menjadi usang.

Contoh:

pola pembelian pelanggan berubah,
kebijakan kredit berubah,
indikator ekonomi bergeser.

Dalam kondisi ini, model perlu retraining.

10.94 Decision Tree pada Data Waktu

Tree dapat dipakai untuk time series jika kita membangun fitur lag.

Contoh:

y_{t-1},
y_{t-2},
moving average,
trend index,
seasonal indicator.

Namun, tree biasa tidak secara inheren memahami struktur waktu.

10.95 Decision Tree untuk Feature Selection

Single tree tidak dirancang khusus sebagai algoritma feature selection formal, tetapi split yang muncul sering memberi petunjuk fitur penting.

Gunakan dengan hati-hati, terutama jika data kecil atau fitur berkorelasi tinggi.

10.96 Decision Tree dan Surrogate Business Rules

Dalam praktik industri, single tree sering dipakai sebagai surrogate model untuk menjelaskan model yang lebih kompleks.

Contoh:

model utama adalah gradient boosting,
lalu dibuat tree kecil untuk menjelaskan pola dominan.

Ini menarik untuk pengajaran lanjutan.

10.97 Ringkasan Formula Penting Decision Tree

10.97.1 Entropy

\[ H(S) = - \sum_{c=1}^{C} p_c \log_2 p_c \]

10.97.2 Information Gain

\[ \text{Gain}(S, A) = H(S) - \sum_v \frac{|S_v|}{|S|} H(S_v) \]

10.97.3 Gini

\[ G(S) = 1 - \sum_{c=1}^{C} p_c^2 \]

10.97.4 Misclassification Error

\[ E(S) = 1 - \max_c p_c \]

10.97.5 Regression Split Objective

\[ \min \sum_{i \in R_1}(y_i - \bar{y}_{R_1})^2 + \sum_{i \in R_2}(y_i - \bar{y}_{R_2})^2 \]

10.97.6 Cost Complexity Pruning

\[ R_\alpha(T) = R(T) + \alpha |T| \]

10.98 Catatan Pengajaran

Jika bab ini dipakai di kelas, saran alokasinya:

20 menit konsep dan intuisi,
25 menit impurity dan split manual,
20 menit demo R,
15 menit pruning dan diskusi,
20 menit latihan interpretasi.

10.99 Latihan Konseptual Tambahan

Mengapa tree disebut model non-parametrik?
Mengapa split awal sangat penting?
Mengapa Gini dan entropy sering memberi split mirip?
Mengapa pruning lebih penting pada single tree dibanding Random Forest?
Mengapa leaf kecil perlu dicurigai?
Mengapa tree bisa menangkap interaksi tanpa menuliskan interaksi?
Mengapa tree tidak butuh standardisasi?
Mengapa single tree bisa tidak stabil?
Mengapa accuracy saja tidak cukup pada data tidak seimbang?
Mengapa interpretabilitas kadang lebih penting daripada akurasi maksimum?

10.100 Latihan Hitung Manual

Sebuah node berisi 8 kelas positif dan 2 negatif. Hitung entropy, Gini, dan misclassification error.
Sebuah split menghasilkan node kiri berisi 5 positif dan 0 negatif, serta node kanan berisi 3 positif dan 2 negatif. Hitung weighted Gini.
Jelaskan apakah split tersebut baik atau tidak.
Untuk regresi, jelaskan mengapa mean dipakai sebagai prediksi leaf.
Apa yang berubah jika loss yang dipakai adalah absolute error?

10.101 Tugas Praktikum Decision Tree

Bangun tree klasifikasi pada iris.
Tampilkan plot tree awal.
Tampilkan cptable.
Lakukan pruning dengan xerror minimum.
Bandingkan akurasi sebelum dan sesudah pruning.
Tulis tiga aturan terpenting dari tree akhir.
Bangun tree regresi pada mtcars.
Hitung RMSE dan MAE.
Bandingkan dengan regresi linear.
Buat refleksi singkat: kapan Anda akan memilih tree, dan kapan tidak.

10.102 Bank Kuis Singkat

Apa arti root node?
Apa arti leaf node?
Apa tujuan utama split?
Apa beda entropy dan Gini?
Apa itu information gain?
Apa itu CART?
Apa itu pruning?
Apa itu cp pada rpart?
Mengapa tree tidak perlu standardisasi?
Mengapa tree rawan overfitting?
Apa beda tree klasifikasi dan regresi?
Apa yang diprediksi leaf pada tree regresi?
Mengapa single tree tidak stabil?
Apa peran maxdepth?
Apa peran minsplit?
Apa arti surrogate split?
Kapan class weights dibutuhkan?
Mengapa tree mudah dijelaskan?
Apa hubungan tree dengan Random Forest?
Apa hubungan tree dengan gradient boosting?

10.103 Kuis Pilihan Ganda

Ukuran impurity yang paling umum pada CART adalah:
1. AIC
2. Gini
3. RMSE
4. VIF
Decision tree regresi umumnya memilih split yang meminimalkan:
1. entropy
2. log-loss
3. residual sum of squares
4. adjusted \(R^2\)
Pruning dilakukan terutama untuk:
1. menambah kompleksitas
2. memperbesar variance
3. mengurangi overfitting
4. menghilangkan target
Decision tree tidak wajib melakukan standardisasi karena:
1. tidak memakai threshold
2. tidak mengukur jarak global antarf fitur
3. hanya untuk data kategorik
4. semua koefisien nol
Jika sebuah tree terlalu dalam, risiko utamanya adalah:
1. underfitting
2. overfitting
3. multikolinearitas
4. heteroskedastisitas

10.104 Kuis Essay

Jelaskan mengapa decision tree disebut model yang sangat interpretatif.
Bandingkan decision tree dengan regresi linear dari sisi bentuk model dan interpretasi.
Jelaskan perbedaan pre-pruning dan post-pruning.
Mengapa single tree menjadi fondasi bagi Random Forest dan boosting?
Jelaskan satu contoh aplikasi decision tree yang relevan dengan bidang Anda.

10.105 Mini Project Decision Tree

Topik yang dapat dipilih:

prediksi kelulusan mahasiswa,
prediksi churn pelanggan,
klasifikasi kredit bermasalah,
prediksi kualitas udara kategori aman atau tidak,
prediksi harga rumah dengan tree regresi.

Output minimal:

deskripsi data,
train-test split,
tree awal,
pruning,
evaluasi,
interpretasi aturan,
rekomendasi keputusan.

10.106 Kapan Decision Tree Cocok?

saat interpretasi sangat penting,
saat relasi non-linear dan interaksi diduga kuat,
saat ingin model yang mudah dijelaskan ke non-teknis,
saat ingin memahami struktur aturan data sebelum beralih ke ensemble.

10.107 Tugas

Bangun decision tree klasifikasi pada iris.
Hitung confusion matrix dan akurasi test set.
Lakukan pruning dan bandingkan hasil sebelum dan sesudah pruning.
Bangun decision tree regresi pada mtcars.
Hitung RMSE, MAE, dan \(R^2\).
Bandingkan hasil tree regresi dengan regresi linear.
Tulis minimal lima aturan interpretatif dari model yang Anda bangun.
Buat kesimpulan kapan tree cocok dan kapan kurang cocok.

10.108 Kuis Singkat

Apa beda entropy dan Gini?
Mengapa decision tree mudah overfitting?
Apa fungsi pruning?
Mengapa decision tree disukai untuk interpretasi?
Apakah decision tree perlu standardisasi fitur?
Apa yang dimaksud impurity?
Mengapa CART memakai binary split?
Apa arti cp pada rpart?
Mengapa single tree lebih tidak stabil daripada Random Forest?
Apa prediksi dalam leaf untuk regresi?

10.109 Ringkasan

Decision tree adalah model supervised berbasis aturan yang membagi ruang fitur menjadi region-region sederhana.

Untuk klasifikasi, tree memilih split yang menurunkan impurity.

Untuk regresi, tree memilih split yang menurunkan galat dalam node.

Keunggulan utamanya adalah interpretabilitas, kemampuan menangkap non-linearitas, dan kemudahan komunikasi hasil.

Keterbatasan utamanya adalah ketidakstabilan dan kecenderungan overfitting pada single tree.

Karena itu, penguasaan konsep split, impurity, dan pruning sangat penting sebelum melangkah ke Random Forest dan boosting.

11 Supervised Learning III: Random Forest

11.1 Tujuan Pembelajaran

Setelah bab ini, pembaca mampu:

Menjelaskan konsep bagging.
Menjelaskan mengapa random feature selection penting.
Memahami out-of-bag error.
Mengimplementasikan Random Forest di R.

11.2 Dari Decision Tree ke Random Forest

Satu pohon keputusan mudah overfitting. Random Forest mengurangi masalah ini dengan membangun banyak pohon dari bootstrap sample dan mengacak subset fitur pada tiap split.

Prediksi akhir:

klasifikasi: voting mayoritas,
regresi: rata-rata prediksi seluruh pohon.

11.3 Bagging

Bagging atau bootstrap aggregating bekerja sebagai berikut:

Ambil banyak bootstrap sample dari data latih.
Bangun satu pohon untuk tiap sample.
Gabungkan prediksi semua pohon.

11.4 Random Subspace

Pada setiap split, hanya sebagian fitur yang boleh dipertimbangkan. Hal ini menurunkan korelasi antar pohon sehingga ensemble menjadi lebih kuat.

11.5 Out-of-Bag Error

Setiap bootstrap sample menyisakan sebagian observasi di luar sampel. Observasi tersebut dapat dipakai untuk estimasi error tanpa perlu validation set terpisah.

11.6 Contoh R: Random Forest

library(randomForest)

set.seed(123)
rf_fit <- randomForest(
  Species ~ .,
  data = iris,
  ntree = 500,
  mtry = 2,
  importance = TRUE
)

print(rf_fit)

#> 
#> Call:
#>  randomForest(formula = Species ~ ., data = iris, ntree = 500,      mtry = 2, importance = TRUE) 
#>                Type of random forest: classification
#>                      Number of trees: 500
#> No. of variables tried at each split: 2
#> 
#>         OOB estimate of  error rate: 4.67%
#> Confusion matrix:
#>            setosa versicolor virginica class.error
#> setosa         50          0         0        0.00
#> versicolor      0         47         3        0.06
#> virginica       0          4        46        0.08

importance(rf_fit)

#>                 setosa versicolor virginica MeanDecreaseAccuracy
#> Sepal.Length  6.495113   7.588736  7.690949            11.098105
#> Sepal.Width   4.364415   1.038790  4.546158             5.144762
#> Petal.Length 22.157039  34.060864 27.853055            33.535680
#> Petal.Width  22.482214  32.571528 30.595022            32.839577
#>              MeanDecreaseGini
#> Sepal.Length         9.798189
#> Sepal.Width          2.236535
#> Petal.Length        43.093269
#> Petal.Width         44.042372

varImpPlot(rf_fit)

11.7 Parameter Penting

ntree: jumlah pohon,
mtry: jumlah fitur kandidat di tiap split,
nodesize: ukuran node minimum,
importance: apakah ingin menghitung pentingnya variabel.

11.8 Kelebihan dan Keterbatasan

Kelebihan:

akurat,
stabil,
menangani non-linearitas dan interaksi.

Keterbatasan:

interpretasi tidak sesederhana single tree,
ukuran model lebih besar,
tidak selalu terbaik pada data yang sangat kecil.

11.9 Tugas

Bangun Random Forest untuk klasifikasi iris.
Ubah mtry dan ntree, lalu amati perubahan OOB error.
Jelaskan variabel terpenting menurut model.

11.10 Kuis Singkat

Apa itu bootstrap sample?
Mengapa Random Forest lebih stabil daripada decision tree tunggal?
Apa fungsi mtry?
Apa itu OOB error?
Mengapa Random Forest termasuk ensemble learning?

11.11 Ringkasan

Random Forest adalah kombinasi efektif antara bagging dan random feature selection. Model ini sering menjadi baseline kuat untuk banyak masalah klasifikasi dan regresi.

12 Supervised Learning IV: Support Vector Machine

12.1 Tujuan Pembelajaran

Pembaca mampu:

Menjelaskan margin maksimum pada SVM.
Menuliskan formulasi hard margin dan soft margin.
Memahami fungsi kernel.
Mengimplementasikan SVM klasifikasi di R.

12.2 Ide Dasar SVM

SVM mencari hyperplane yang memisahkan kelas dengan margin terbesar.

Hyperplane linear:

\[ f(x) = \beta^\top x + b \]

Prediksi kelas:

\[ \hat{y} = \mathrm{sign}(\beta^\top x + b) \]

12.3 Hard Margin SVM

Jika data terpisah sempurna, optimisasi:

\[ \min_{\beta,b} \frac{1}{2}\lVert \beta \rVert^2 \]

dengan kendala:

\[ y_i(\beta^\top x_i + b) \geq 1, \quad i=1,\ldots,n \]

12.4 Soft Margin SVM

Untuk data yang tidak terpisah sempurna:

\[ \min_{\beta,b,\xi} \frac{1}{2}\lVert \beta \rVert^2 + C\sum_{i=1}^{n}\xi_i \]

dengan:

\[ y_i(\beta^\top x_i + b) \geq 1 - \xi_i, \quad \xi_i \geq 0 \]

Parameter \(C\) mengontrol trade-off antara margin besar dan penalti salah klasifikasi.

12.5 Kernel Trick

Jika boundary tidak linear, SVM menggunakan kernel:

linear,
polynomial,
radial basis function,
sigmoid.

Kernel RBF yang populer:

\[ K(x_i, x_j) = \exp(-\gamma \lVert x_i - x_j \rVert^2) \]

12.6 Contoh R: SVM Klasifikasi

library(e1071)

iris_bin <- subset(iris, Species != "virginica")
set.seed(123)
idx <- sample(seq_len(nrow(iris_bin)), size = 0.7 * nrow(iris_bin))
train_bin <- iris_bin[idx, ]
test_bin  <- iris_bin[-idx, ]

svm_linear <- svm(
  Species ~ .,
  data = train_bin,
  kernel = "linear",
  cost = 1,
  scale = TRUE
)

svm_rbf <- svm(
  Species ~ .,
  data = train_bin,
  kernel = "radial",
  cost = 1,
  gamma = 0.5,
  scale = TRUE
)

pred_linear <- predict(svm_linear, newdata = test_bin)
pred_rbf    <- predict(svm_rbf, newdata = test_bin)

mean(pred_linear == test_bin$Species)

#> [1] 1

mean(pred_rbf == test_bin$Species)

#> [1] 1

12.7 Panduan Praktis

SVM sensitif terhadap skala fitur, jadi standardisasi penting.
Tuning cost dan gamma menentukan performa.
Kernel linear cocok jika jumlah fitur besar dan boundary mendekati linear.

12.8 Tugas

Bangun SVM linear dan radial pada data dua kelas.
Bandingkan akurasi keduanya.
Lakukan tuning sederhana pada cost dan gamma.

12.9 Kuis Singkat

Apa itu margin pada SVM?
Apa bedanya hard margin dan soft margin?
Mengapa hanya sebagian observasi menjadi support vectors?
Apa fungsi kernel?
Mengapa standardisasi penting pada SVM?

12.10 Ringkasan

SVM adalah metode klasifikasi yang sangat kuat, khususnya pada data berdimensi sedang hingga tinggi. Inti kekuatannya ada pada margin maksimum dan kernel trick.

13 Supervised Learning V: Support Vector Regression

13.1 Tujuan Pembelajaran

Setelah mempelajari bab ini, pembaca mampu:

Menjelaskan SVR sebagai perluasan SVM ke regresi.
Memahami epsilon-insensitive loss.
Menjelaskan peran parameter cost, epsilon, dan kernel.
Mengimplementasikan SVR di R.

13.2 Konsep Dasar SVR

SVR berusaha menemukan fungsi yang sedatar mungkin tetapi tetap menjaga kesalahan prediksi di dalam tabung toleransi \(\epsilon\).

Model linear:

\[ f(x) = \beta^\top x + b \]

Objective function:

\[ \min_{\beta,b,\xi,\xi^*} \frac{1}{2}\lVert \beta \rVert^2 + C \sum_{i=1}^{n}(\xi_i + \xi_i^*) \]

dengan kendala:

\[ y_i - (\beta^\top x_i + b) \leq \epsilon + \xi_i \]

\[ (\beta^\top x_i + b) - y_i \leq \epsilon + \xi_i^* \]

\[ \xi_i, \xi_i^* \geq 0 \]

13.3 Epsilon-Insensitive Loss

Loss-nya nol selama prediksi berada dalam radius \(\epsilon\) dari nilai aktual. Hal ini membuat SVR fokus pada kesalahan yang benar-benar penting.

13.4 Contoh R: SVR

library(e1071)

set.seed(123)
idx <- sample(seq_len(nrow(mtcars)), size = 0.75 * nrow(mtcars))
train_reg <- mtcars[idx, ]
test_reg  <- mtcars[-idx, ]

svr_fit <- svm(
  mpg ~ wt + hp + disp,
  data = train_reg,
  type = "eps-regression",
  kernel = "radial",
  cost = 10,
  epsilon = 0.1,
  gamma = 0.1,
  scale = TRUE
)

svr_pred <- predict(svr_fit, newdata = test_reg)
rmse_svr <- sqrt(mean((test_reg$mpg - svr_pred)^2))
rmse_svr

#> [1] 2.607152

13.5 Perbandingan Singkat SVR vs Regresi Linear

Aspek	Regresi Linear	SVR
Bentuk hubungan	linear	linear atau non-linear via kernel
Interpretasi	tinggi	lebih rendah
Tuning	rendah	tinggi
Fleksibilitas	sedang	tinggi

13.6 Tugas

Gunakan mtcars untuk membandingkan regresi linear dan SVR.
Uji beberapa nilai epsilon.
Bandingkan kernel linear dan radial.

13.7 Kuis Singkat

Apa peran parameter epsilon pada SVR?
Apa perbedaan SVR dan SVM klasifikasi?
Mengapa SVR dapat memodelkan hubungan non-linear?
Apa arti parameter cost pada SVR?
Kapan SVR lebih menarik daripada regresi linear?

13.8 Ringkasan

SVR membawa filosofi margin maksimum ke ranah regresi. Model ini sangat berguna ketika hubungan input-output kompleks dan kita ingin kontrol yang baik atas toleransi galat.

14 Neural Network dan Deep Learning

14.1 Tujuan Pembelajaran

Pembaca mampu:

Menjelaskan struktur neuron buatan.
Menjelaskan multilayer perceptron.
Memahami aktivasi, loss function, dan backpropagation.
Mengimplementasikan neural network sederhana di R.

14.2 Neuron Buatan

Satu neuron menghitung kombinasi linear lalu menerapkan fungsi aktivasi:

\[ z = w_0 + \sum_{j=1}^{p} w_j x_j \]

\[ a = g(z) \]

Fungsi aktivasi yang umum:

sigmoid,
tanh,
ReLU,
softmax untuk output multikelas.

14.3 Multilayer Perceptron

Neural network terdiri dari:

input layer,
satu atau lebih hidden layer,
output layer.

Komposisi fungsi untuk jaringan satu hidden layer:

\[ \hat{y} = g_2\left(W^{(2)} g_1\left(W^{(1)}x + b^{(1)}\right) + b^{(2)}\right) \]

14.4 Loss Function

Untuk klasifikasi biner sering dipakai binary cross-entropy:

\[ L = -\frac{1}{n}\sum_{i=1}^{n}\left[y_i\log(\hat{p}_i) + (1-y_i)\log(1-\hat{p}_i)\right] \]

Untuk regresi sering dipakai MSE.

14.5 Backpropagation

Backpropagation menghitung turunan loss terhadap semua bobot dengan aturan rantai. Setelah gradien diperoleh, parameter diperbarui dengan gradient descent atau variannya.

14.6 Deep Learning

Jika hidden layer bertambah banyak, model masuk ke kategori deep learning. Kelebihannya:

mampu mempelajari representasi kompleks,
unggul pada citra, teks, audio, dan data tidak terstruktur.

Tantangannya:

butuh data lebih besar,
tuning lebih sulit,
komputasi lebih mahal.

14.7 Contoh R: Neural Network Sederhana

library(nnet)

set.seed(123)
idx <- sample(seq_len(nrow(iris)), size = 0.7 * nrow(iris))
train_nn <- iris[idx, ]
test_nn  <- iris[-idx, ]

nn_fit <- nnet(
  Species ~ .,
  data = train_nn,
  size = 5,
  decay = 0.01,
  maxit = 500,
  trace = FALSE
)

nn_pred <- predict(nn_fit, newdata = test_nn, type = "class")
table(Prediksi = nn_pred, Aktual = test_nn$Species)

#>             Aktual
#> Prediksi     setosa versicolor virginica
#>   setosa         14          0         0
#>   versicolor      0         17         0
#>   virginica       0          1        13

mean(nn_pred == test_nn$Species)

#> [1] 0.9777778

14.8 Catatan Praktis

scale fitur untuk membantu optimisasi,
mulai dari arsitektur kecil,
gunakan regularisasi seperti weight decay atau dropout pada model yang lebih besar,
siapkan validation set untuk menghindari overfitting.

14.9 Tugas

Bangun neural network sederhana pada iris.
Bandingkan hasilnya dengan K-NN atau decision tree.
Uji pengaruh jumlah hidden units terhadap akurasi.

14.10 Kuis Singkat

Apa fungsi hidden layer?
Mengapa fungsi aktivasi non-linear penting?
Apa itu backpropagation?
Mengapa neural network rawan overfitting?
Kapan deep learning benar-benar dibutuhkan?

14.11 Ringkasan

Neural network memperluas ide regresi dan optimisasi menjadi arsitektur berlapis yang sangat fleksibel. Ini adalah fondasi untuk deep learning modern.

15 Validation dan Evaluation

15.1 Tujuan Pembelajaran

Pembaca mampu:

Menjelaskan perbedaan hold-out, validation set, dan k-fold cross-validation.
Menghitung confusion matrix dan metrik klasifikasi.
Menghitung metrik regresi yang umum.
Memilih metrik evaluasi sesuai tujuan analisis.

15.2 Mengapa Evaluasi Penting?

Model yang sangat baik di data latih belum tentu baik pada data baru. Karena itu evaluasi harus dilakukan secara out-of-sample.

15.3 Hold-Out Validation

Data dibagi menjadi train dan test. Kadang ditambah validation set untuk tuning.

Kelebihan:

sederhana,
cepat.

Kekurangan:

hasil bergantung pada satu pembagian data.

15.4 K-Fold Cross-Validation

Data dibagi menjadi \(K\) fold. Setiap fold bergiliran menjadi validation set, sementara sisanya menjadi training set.

\[ \text{CV Error} = \frac{1}{K}\sum_{k=1}^{K}\text{Error}_k \]

Kelebihan:

lebih stabil,
efisien untuk data terbatas.

15.5 Confusion Matrix

Untuk klasifikasi biner:

	Prediksi Positif	Prediksi Negatif
Aktual Positif	TP	FN
Aktual Negatif	FP	TN

Metrik penting:

\[ \text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN} \]

\[ \text{Precision} = \frac{TP}{TP + FP} \]

\[ \text{Recall} = \frac{TP}{TP + FN} \]

\[ F1 = 2 \cdot \frac{\text{Precision} \cdot \text{Recall}} {\text{Precision} + \text{Recall}} \]

15.6 Metrik Regresi

\[ \text{MAE} = \frac{1}{n}\sum_{i=1}^{n}|y_i - \hat{y}_i| \]

\[ \text{RMSE} = \sqrt{\frac{1}{n}\sum_{i=1}^{n}(y_i - \hat{y}_i)^2} \]

\[ R^2 = 1 - \frac{\sum_{i=1}^{n}(y_i - \hat{y}_i)^2} {\sum_{i=1}^{n}(y_i - \bar{y})^2} \]

15.7 Contoh R: K-Fold Cross-Validation Sederhana

set.seed(123)
k <- 5
fold_id <- sample(rep(1:k, length.out = nrow(iris)))
acc <- numeric(k)

for (i in 1:k) {
  train_cv <- iris[fold_id != i, ]
  test_cv  <- iris[fold_id == i, ]

  fit_cv <- glm(Species == "setosa" ~ Sepal.Length + Sepal.Width +
                  Petal.Length + Petal.Width,
                data = train_cv, family = binomial())

  prob_cv <- predict(fit_cv, newdata = test_cv, type = "response")
  pred_cv <- ifelse(prob_cv > 0.5, TRUE, FALSE)
  acc[i] <- mean(pred_cv == (test_cv$Species == "setosa"))
}

mean(acc)

#> [1] 1

15.8 Contoh R: Menghitung Metrik Secara Manual

actual <- c(1, 1, 1, 0, 0, 0, 1, 0)
pred   <- c(1, 1, 0, 0, 0, 1, 1, 0)

TP <- sum(actual == 1 & pred == 1)
TN <- sum(actual == 0 & pred == 0)
FP <- sum(actual == 0 & pred == 1)
FN <- sum(actual == 1 & pred == 0)

accuracy  <- (TP + TN) / (TP + TN + FP + FN)
precision <- TP / (TP + FP)
recall    <- TP / (TP + FN)
f1        <- 2 * precision * recall / (precision + recall)

c(accuracy = accuracy, precision = precision, recall = recall, f1 = f1)

#>  accuracy precision    recall        f1 
#>      0.75      0.75      0.75      0.75

15.9 Memilih Metrik yang Tepat

Gunakan accuracy bila kelas relatif seimbang.
Gunakan precision bila false positive mahal.
Gunakan recall bila false negative mahal.
Gunakan F1 bila perlu kompromi precision dan recall.
Gunakan RMSE bila ingin menghukum error besar lebih keras.
Gunakan MAE bila ingin metrik yang lebih robust terhadap outlier.

15.10 Tugas

Hitung confusion matrix dan metrik klasifikasi dari model pilihan Anda.
Lakukan 5-fold cross-validation pada satu model klasifikasi.
Bandingkan MAE dan RMSE pada satu model regresi.

15.11 Kuis Singkat

Kapan accuracy menyesatkan?
Apa perbedaan validation set dan test set?
Mengapa cross-validation lebih stabil dari single split?
Kapan recall lebih penting dari precision?
Mengapa test set tidak boleh dipakai untuk tuning?

15.12 Ringkasan

Evaluasi yang benar adalah syarat utama machine learning yang valid. Metrik harus dipilih berdasarkan tujuan, biaya kesalahan, dan karakter data.

16 UAS: Project Kelompok 2 Orang

16.1 Tujuan Proyek Akhir

UAS menilai kemampuan akhir mahasiswa untuk menyusun proyek machine learning dari awal sampai akhir secara utuh dan profesional.

Kemampuan yang diuji:

problem framing,
data understanding,
pemilihan model,
validasi dan evaluasi,
komunikasi hasil,
refleksi terhadap keterbatasan.

16.2 Ketentuan Umum

proyek dikerjakan oleh kelompok 2 orang,
data harus nyata dan relevan,
minimal membandingkan 3 model,
wajib ada validasi yang benar,
wajib ada presentasi dan report akhir.

16.3 Deliverables Wajib

Notebook atau script R yang rapi.
Report akhir lengkap.
Slide presentasi.
Ringkasan eksekutif 1 halaman.

16.4 Struktur Report UAS

Judul dan abstrak.
Latar belakang dan tujuan.
Tinjauan data dan literature singkat.
Metodologi.
Eksplorasi data.
Feature engineering.
Pemodelan dan tuning.
Evaluasi dan perbandingan model.
Interpretasi hasil.
Keterbatasan dan saran pengembangan.
Lampiran kode penting.

16.5 Rubrik Penilaian UAS

Komponen	Bobot
Kejelasan masalah dan nilai analisis	15%
Kualitas data cleaning dan EDA	15%
Ketepatan metode dan tuning	20%
Validasi, evaluasi, dan interpretasi	25%
Report akhir	15%
Presentasi	10%

16.6 Saran Alur Pengerjaan

Pilih masalah yang datanya cukup.
Tetapkan target dan satuan evaluasi sejak awal.
Bangun baseline.
Bandingkan beberapa model.
Simpulkan model terbaik bukan hanya dari akurasi, tetapi juga dari justifikasi.

16.7 Kriteria Proyek yang Baik

pertanyaan analisis jelas,
data layak dan terdokumentasi,
tidak ada kebocoran data,
model dan evaluasi konsisten dengan tujuan,
hasil bisa dijelaskan ke audiens non-teknis.

16.8 Tugas Akhir

Siapkan proposal final berisi topik, dataset, target, model kandidat, dan metrik.
Pastikan semua kode dapat dijalankan dari awal sampai akhir.
Siapkan presentasi 10 sampai 15 menit.

16.9 Kuis Reflektif

Apa perbedaan proyek UTS dan UAS secara kedalaman?
Mengapa interpretasi hasil sama pentingnya dengan akurasi?
Apa arti reprodusibilitas dalam proyek akhir?
Mengapa keterbatasan studi harus ditulis?
Bagaimana Anda membela pilihan model terbaik di depan penguji?

16.10 Ringkasan

UAS adalah sintesis seluruh mata kuliah. Mahasiswa tidak hanya dituntut menjalankan model, tetapi juga membuktikan bahwa proses analisisnya logis, bersih, dan dapat dipertanggungjawabkan.

Lampiran A: Peta Praktikum dan Studi Kasus per Pertemuan

Lampiran ini dirancang agar dosen atau mahasiswa dapat langsung mengubah setiap bab menjadi sesi praktikum.

Setiap pertemuan dilengkapi dengan:

konteks masalah,
tujuan teknis,
dataset yang bisa dipakai,
langkah kerja,
output minimum,
ide diskusi kelas.

16.11 Pertemuan 1: Perkenalan Machine Learning

16.11.1 Konteks

Mahasiswa sering mengenal machine learning sebagai daftar algoritma.

Padahal, yang paling penting di awal adalah memahami tipe masalah, tipe data, dan alur kerja analisis.

16.11.2 Tujuan Praktikum

Mengidentifikasi perbedaan regresi, klasifikasi, clustering, dan reduksi dimensi.
Memetakan contoh kasus ke tipe masalah yang tepat.
Melatih kebiasaan train-test split sejak awal.

16.11.3 Dataset yang Disarankan

iris
mtcars
USArrests

16.11.4 Langkah Kerja

Buka ketiga dataset.
Identifikasi jenis target pada masing-masing dataset.
Tentukan mana yang cocok untuk regresi, klasifikasi, dan clustering.
Lakukan split sederhana untuk iris.
Tulis alasan mengapa evaluasi out-of-sample diperlukan.

16.11.5 Output Minimum

tabel nama dataset,
tipe target,
jenis masalah,
rencana evaluasi.

16.11.6 Diskusi Kelas

Mengapa machine learning tidak identik dengan artificial intelligence?
Mengapa satu dataset bisa dipakai untuk pertanyaan yang berbeda?
Mengapa pemahaman masalah lebih penting daripada langsung memilih algoritma?

16.12 Pertemuan 2: Analisis Regresi dan Gradient Descent

16.12.1 Konteks

Bab ini penting karena mahasiswa perlu memahami bahwa banyak algoritma machine learning pada dasarnya adalah optimisasi loss.

16.12.2 Tujuan Praktikum

Membandingkan solusi analitik OLS dan solusi iteratif gradient descent.
Mengamati pengaruh learning rate.
Melihat konvergensi loss dari waktu ke waktu.

16.12.3 Dataset yang Disarankan

mtcars

16.12.4 Langkah Kerja

Bangun model lm() untuk mpg.
Implementasikan gradient descent manual.
Coba tiga nilai learning rate.
Simpan history loss.
Bandingkan koefisien dan RMSE.

16.12.5 Output Minimum

tabel koefisien OLS,
tabel koefisien gradient descent,
plot konvergensi,
interpretasi singkat.

16.12.6 Diskusi Kelas

Apa yang terjadi jika learning rate terlalu kecil?
Apa yang terjadi jika terlalu besar?
Mengapa scaling fitur dapat membantu gradient descent?

16.13 Pertemuan 3: Ridge, Lasso, Elastic Net

16.13.1 Konteks

Mahasiswa sering melihat banyak variabel sebagai hal yang selalu baik.

Padahal, banyak prediktor dapat memicu overfitting dan ketidakstabilan koefisien.

16.13.2 Tujuan Praktikum

Menjelaskan kebutuhan regularisasi.
Membedakan efek shrinkage dan seleksi fitur.
Memakai cross-validation untuk memilih lambda.

16.13.3 Dataset yang Disarankan

mtcars
data sintetis dengan fitur berkorelasi tinggi

16.13.4 Langkah Kerja

Siapkan matriks desain.
Jalankan cv.glmnet() untuk Ridge.
Jalankan cv.glmnet() untuk Lasso.
Jalankan cv.glmnet() untuk Elastic Net.
Bandingkan koefisien akhir.

16.13.5 Output Minimum

plot cross-validation,
tabel koefisien untuk tiap metode,
daftar fitur yang nol pada Lasso,
RMSE pembandingan.

16.13.6 Diskusi Kelas

Mengapa Ridge tidak memaksa koefisien tepat nol?
Mengapa Lasso dapat memilih variabel?
Kapan Elastic Net lebih aman daripada Lasso?

16.14 Pertemuan 4: PCA dan Analisis Faktor

16.14.1 Konteks

Pada data sosial, ekonomi, dan survei, jumlah variabel sering terlalu banyak dan saling berkorelasi.

16.14.2 Tujuan Praktikum

Melakukan PCA berbasis standardisasi.
Membaca scree plot.
Membedakan tujuan PCA dan analisis faktor.

16.14.3 Dataset yang Disarankan

USArrests
data survei internal

16.14.4 Langkah Kerja

Standarkan data numerik.
Jalankan prcomp().
Tampilkan proporsi varian.
Buat scree plot.
Jalankan factanal() dengan satu faktor pada USArrests.
Bandingkan loading PCA dan factor loading.

16.14.5 Output Minimum

scree plot,
tabel proporsi varian,
matriks loading,
interpretasi komponen/faktor.

16.14.6 Diskusi Kelas

Mengapa PCA sensitif terhadap skala?
Kapan PCA dipakai sebelum modeling?
Mengapa analisis faktor lebih cocok untuk konstruk laten?

16.15 Pertemuan 5: Hierarchical Clustering dan K-Medoids

16.15.1 Konteks

Clustering berbasis jarak perlu diajarkan dengan hati-hati karena mahasiswa sering mengira cluster selalu memiliki jawaban benar tunggal.

16.15.2 Tujuan Praktikum

Membuat matriks jarak.
Membangun dendrogram dengan linkage berbeda.
Membandingkan hasil hierarchical clustering dengan K-medoids.

16.15.3 Dataset yang Disarankan

USArrests
data pelanggan sederhana

16.15.4 Langkah Kerja

Standarkan variabel.
Hitung jarak Euclidean.
Bangun dendrogram complete, average, dan ward.
Potong dendrogram pada beberapa k.
Jalankan pam().
Bandingkan silhouette.

16.15.5 Output Minimum

dendrogram,
tabel alokasi cluster,
nilai silhouette,
interpretasi per cluster.

16.15.6 Diskusi Kelas

Mengapa linkage method dapat mengubah hasil?
Mengapa K-medoids lebih robust terhadap outlier?
Apakah jumlah cluster harus selalu dicari secara otomatis?

16.16 Pertemuan 6: K-Means dan Fuzzy C-Means

16.16.1 Konteks

Bab ini memperkenalkan perbedaan cluster keras dan cluster lunak.

16.16.2 Tujuan Praktikum

Menjalankan K-means dengan beberapa nstart.
Membaca pusat cluster.
Menafsirkan keanggotaan fuzzy pada FCM.

16.16.3 Dataset yang Disarankan

iris

16.16.4 Langkah Kerja

Standarkan fitur iris.
Jalankan K-means untuk k = 3.
Jalankan K-means beberapa kali dengan nstart berbeda.
Jalankan cmeans().
Bandingkan hasil cluster keras dan fuzzy.

16.16.5 Output Minimum

pusat cluster,
tabel cluster versus spesies,
tabel membership fuzzy,
refleksi perbedaan interpretasi.

16.16.6 Diskusi Kelas

Mengapa K-means sensitif terhadap inisialisasi?
Kapan FCM lebih realistis?
Mengapa cluster tidak sama dengan klasifikasi?

16.17 Pertemuan 7: Gradient Boosting untuk Regresi dan Time Series

16.17.1 Konteks

Mahasiswa perlu belajar bahwa boosting kuat, tetapi tidak otomatis menjadi pilihan terbaik tanpa tuning.

16.17.2 Tujuan Praktikum

Menjalankan gradient boosting untuk regresi.
Mengubah time series menjadi supervised learning berbasis lag.
Membandingkan boosting dengan baseline linear.

16.17.3 Dataset yang Disarankan

mtcars
AirPassengers

16.17.4 Langkah Kerja

Bangun model gbm untuk mtcars.
Pilih n.trees terbaik.
Bentuk fitur lag1 dan lag12 untuk AirPassengers.
Jalankan model boosting time series.
Bandingkan RMSE dengan baseline.

16.17.5 Output Minimum

importance plot,
RMSE train/test,
tabel fitur lag,
interpretasi prediksi.

16.17.6 Diskusi Kelas

Mengapa time series dapat diubah menjadi supervised learning?
Apa dampak learning rate kecil?
Mengapa boosting rawan overfitting jika tidak dikendalikan?

16.18 Pertemuan 8: UTS Project

16.18.1 Konteks

UTS adalah latihan menyusun workflow yang utuh, bukan sekadar menjalankan fungsi R.

16.18.2 Tujuan Praktikum

Menulis rumusan masalah yang dapat diukur.
Menentukan target, fitur, dan metrik.
Menyusun alur kerja analisis.

16.18.3 Dataset yang Disarankan

dataset terbuka Kaggle,
data BPS,
data pemerintah,
data internal kelas.

16.18.4 Langkah Kerja

Pilih masalah.
Identifikasi target.
Tulis baseline model.
Tentukan dua model kandidat.
Rancang struktur report.

16.18.5 Output Minimum

proposal 1 sampai 2 halaman,
daftar variabel,
hipotesis awal,
rencana evaluasi.

16.18.6 Diskusi Kelas

Mengapa data leakage harus dihindari sejak proposal?
Mengapa baseline wajib ditentukan di awal?
Bagaimana menilai apakah masalah yang dipilih realistis?

16.19 Pertemuan 9: Naive Bayes dan K-NN

16.19.1 Konteks

Bab ini berguna untuk memperlihatkan dua filosofi klasifikasi yang sangat berbeda:

probabilistik,
berbasis kedekatan tetangga.

16.19.2 Tujuan Praktikum

Menjalankan Naive Bayes.
Menjalankan K-NN dengan beberapa k.
Menjelaskan dampak standardisasi pada K-NN.

16.19.3 Dataset yang Disarankan

iris

16.19.4 Langkah Kerja

Lakukan split train-test.
Bangun Naive Bayes.
Hitung akurasi.
Standardisasi fitur untuk K-NN.
Uji k = 3, 5, 7, 9.
Bandingkan performa.

16.19.5 Output Minimum

confusion matrix,
tabel akurasi per nilai k,
interpretasi perbandingan model.

16.19.6 Diskusi Kelas

Mengapa Naive Bayes tetap bisa bagus walau asumsi independensi tidak sepenuhnya benar?
Mengapa K-NN termasuk lazy learner?
Mengapa k kecil rawan overfitting?

16.20 Pertemuan 10: Decision Tree

16.20.1 Konteks

Bab ini menjadi jembatan menuju ensemble tree.

16.20.2 Tujuan Praktikum

Membangun tree klasifikasi dan regresi.
Membaca cptable.
Melakukan pruning.
Mengekstrak aturan keputusan.

16.20.3 Dataset yang Disarankan

iris
mtcars

16.20.4 Langkah Kerja

Bangun tree klasifikasi pada iris.
Tampilkan plot awal.
Lakukan pruning.
Hitung confusion matrix.
Bangun tree regresi pada mtcars.
Hitung RMSE, MAE, dan \(R^2\).

16.20.5 Output Minimum

plot tree,
tabel cp,
aturan utama,
perbandingan sebelum dan sesudah pruning.

16.20.6 Diskusi Kelas

Mengapa single tree tidak stabil?
Mengapa tree tidak perlu standardisasi?
Mengapa tree mudah dijelaskan ke stakeholder?

16.21 Pertemuan 11: Random Forest

16.21.1 Konteks

Mahasiswa perlu melihat secara nyata bagaimana banyak pohon dapat menurunkan variance.

16.21.2 Tujuan Praktikum

Menjalankan Random Forest.
Membaca OOB error.
Menafsirkan variable importance.

16.21.3 Dataset yang Disarankan

iris
dataset klasifikasi lain

16.21.4 Langkah Kerja

Jalankan randomForest().
Ubah ntree.
Ubah mtry.
Catat perubahan OOB error.
Tampilkan importance plot.

16.21.5 Output Minimum

ringkasan model,
grafik importance,
tabel hasil eksperimen parameter.

16.21.6 Diskusi Kelas

Mengapa banyak pohon lebih stabil?
Apa fungsi bootstrap sample?
Mengapa OOB error berguna?

16.22 Pertemuan 12: SVM

16.22.1 Konteks

Bab ini memperkenalkan klasifikasi berbasis margin maksimum.

16.22.2 Tujuan Praktikum

Menjalankan SVM linear dan radial.
Membandingkan akurasi.
Menjelaskan peran cost dan gamma.

16.22.3 Dataset yang Disarankan

subset dua kelas dari iris

16.22.4 Langkah Kerja

Bentuk data biner.
Split train-test.
Jalankan SVM linear.
Jalankan SVM radial.
Bandingkan hasil.

16.22.5 Output Minimum

akurasi,
confusion matrix,
tabel parameter,
interpretasi perbedaan kernel.

16.22.6 Diskusi Kelas

Apa arti support vector?
Mengapa scaling penting pada SVM?
Kapan kernel radial lebih bermanfaat?

16.23 Pertemuan 13: SVR

16.23.1 Konteks

SVR memperkenalkan versi regresi dari margin maksimum.

16.23.2 Tujuan Praktikum

Menjalankan SVR linear dan radial.
Menjelaskan arti epsilon.
Membandingkan SVR dan regresi linear.

16.23.3 Dataset yang Disarankan

mtcars

16.23.4 Langkah Kerja

Split data.
Jalankan regresi linear.
Jalankan SVR radial.
Uji beberapa nilai epsilon.
Bandingkan RMSE.

16.23.5 Output Minimum

tabel RMSE,
tabel parameter,
refleksi kapan SVR unggul.

16.23.6 Diskusi Kelas

Mengapa epsilon penting?
Mengapa SVR bisa lebih fleksibel dari regresi linear?
Apa trade-off antara interpretasi dan performa?

16.24 Pertemuan 14: Neural Network dan Deep Learning

16.24.1 Konteks

Mahasiswa perlu memahami neural network sebagai perluasan ide optimisasi, bukan sebagai “algoritma ajaib”.

16.24.2 Tujuan Praktikum

Membangun neural network sederhana.
Mengamati pengaruh jumlah hidden unit.
Membandingkan akurasi dengan model klasik.

16.24.3 Dataset yang Disarankan

iris

16.24.4 Langkah Kerja

Split train-test.
Bangun nnet() dengan size = 3.
Ulangi dengan size = 5 dan size = 7.
Bandingkan akurasi.
Catat waktu komputasi dan stabilitas hasil.

16.24.5 Output Minimum

tabel akurasi per arsitektur,
confusion matrix,
refleksi keterbatasan neural network kecil.

16.24.6 Diskusi Kelas

Mengapa aktivasi non-linear penting?
Mengapa neural network butuh tuning lebih banyak?
Kapan deep learning betul-betul diperlukan?

16.25 Pertemuan 15: Validation dan Evaluation

16.25.1 Konteks

Bab ini harus menutup celah umum mahasiswa yang hanya melaporkan akurasi.

16.25.2 Tujuan Praktikum

Menghitung confusion matrix.
Menghitung precision, recall, dan F1.
Menjalankan k-fold cross-validation.

16.25.3 Dataset yang Disarankan

iris
dataset biner buatan

16.25.4 Langkah Kerja

Bangun model klasifikasi sederhana.
Hitung confusion matrix.
Turunkan accuracy, precision, recall, F1.
Jalankan 5-fold CV.
Jelaskan kapan accuracy menyesatkan.

16.25.5 Output Minimum

confusion matrix,
tabel metrik,
ringkasan cross-validation.

16.25.6 Diskusi Kelas

Mengapa test set tidak boleh dipakai tuning?
Kapan recall lebih penting daripada precision?
Mengapa cross-validation lebih stabil daripada single split?

16.26 Pertemuan 16: UAS Project

16.26.1 Konteks

UAS menuntut sintesis semua materi.

16.26.2 Tujuan Praktikum

Menyusun workflow penuh dari data sampai rekomendasi.
Menulis laporan akhir yang rapi.
Menjelaskan model terbaik beserta keterbatasannya.

16.26.3 Dataset yang Disarankan

dataset nyata pilihan kelompok

16.26.4 Langkah Kerja

Finalisasi tujuan analisis.
Finalisasi train-validation-test protocol.
Bandingkan minimal tiga model.
Pilih model terbaik berdasarkan argumen teknis.
Siapkan report dan slide.

16.26.5 Output Minimum

report akhir,
slide,
script reprodusibel,
ringkasan eksekutif.

16.26.6 Diskusi Kelas

Apa arti proyek yang baik secara akademik?
Mengapa hasil harus dapat dipertanggungjawabkan?
Bagaimana menjelaskan model terbaik kepada audiens non-teknis?

Lampiran B: Bank Soal Pilihan Ganda 1-8

16.27 Soal Pertemuan 1: Perkenalan Machine Learning

Machine learning paling tepat dipahami sebagai:
1. sekumpulan komputer super cepat
2. pendekatan untuk belajar pola dari data
3. metode mengganti statistika
4. teknik membuat grafik
Contoh supervised learning adalah:
1. PCA
2. clustering
3. prediksi harga rumah
4. reduksi dimensi
Contoh unsupervised learning adalah:
1. klasifikasi spam
2. clustering pelanggan
3. prediksi pendapatan
4. regresi linear
Generalisasi berarti:
1. model sangat cocok pada data latih
2. model bagus pada data baru
3. semua fitur dipakai
4. data dibersihkan
Tahap awal yang benar dalam pipeline ML adalah:
1. tuning hyperparameter
2. memilih deep learning
3. merumuskan masalah
4. membuat confusion matrix

16.28 Soal Pertemuan 2: Regresi dan Gradient Descent

Loss yang umum untuk regresi adalah:
1. MSE
2. Gini
3. entropy
4. AUC
Solusi OLS berbentuk:
1. voting mayoritas
2. gradient boosting
3. \((X^\top X)^{-1} X^\top y\)
4. \(\sum p \log p\)
Gradient descent memperbarui parameter dengan:
1. menambah gradien
2. mengurangi gradien
3. menghapus target
4. mengacak koefisien
Learning rate terlalu besar dapat menyebabkan:
1. konvergensi lebih stabil
2. underfitting pasti
3. divergensi atau osilasi
4. fitur hilang
Standardisasi sering membantu gradient descent karena:
1. menambah jumlah data
2. menyamakan skala fitur
3. membuat target kategorik
4. mengganti loss function

16.29 Soal Pertemuan 3: Ridge, Lasso, Elastic Net

Penalti Ridge menggunakan:
1. norma L1
2. norma L2
3. entropy
4. Gini
Lasso dapat melakukan seleksi fitur karena:
1. memakai bootstrap
2. memakai margin maksimum
3. sebagian koefisien dapat menjadi nol
4. memakai k-fold otomatis
Elastic Net cocok ketika:
1. semua fitur independen sempurna
2. fitur berkorelasi dan ingin seleksi
3. hanya ada satu prediktor
4. target harus biner
Nilai alpha = 0 pada glmnet berarti:
1. Lasso
2. Elastic Net
3. Ridge
4. PCA
lambda.min pada cv.glmnet adalah:
1. lambda terbesar
2. lambda dengan error CV minimum
3. jumlah fold
4. jumlah fitur aktif

16.30 Soal Pertemuan 4: PCA dan Analisis Faktor

Tujuan utama PCA adalah:
1. uji hipotesis
2. reduksi dimensi
3. imputasi data
4. validasi silang
PCA biasanya dilakukan pada data yang:
1. hanya kategorik
2. banyak variabel dan saling berkorelasi
3. tanpa variabel numerik
4. selalu time series
Eigenvalue besar pada PCA menunjukkan:
1. error besar
2. komponen menjelaskan variasi besar
3. data salah input
4. cluster banyak
Analisis faktor berfokus pada:
1. common variance dan faktor laten
2. random forest
3. data biner saja
4. gradient descent
Standardisasi penting pada PCA karena:
1. PCA berbasis kovarians atau korelasi
2. target harus nol
3. data harus integer
4. mengurangi jumlah observasi

16.31 Soal Pertemuan 5: Hierarchical Clustering dan K-Medoids

Dendrogram dihasilkan oleh:
1. K-NN
2. hierarchical clustering
3. ridge regression
4. Naive Bayes
Complete linkage memakai:
1. jarak minimum
2. jarak maksimum
3. rata-rata target
4. probabilitas posterior
K-medoids lebih robust terhadap outlier karena:
1. memakai medoid sebagai observasi nyata
2. tidak memakai jarak
3. hanya untuk data biner
4. memakai kernel
Clustering termasuk:
1. supervised learning
2. reinforcement learning
3. unsupervised learning
4. deep learning saja
Standardisasi fitur penting pada clustering berbasis jarak karena:
1. semua variabel harus nominal
2. jarak sensitif terhadap skala
3. jumlah cluster otomatis jadi optimal
4. tidak ada alasan teknis

16.32 Soal Pertemuan 6: K-Means dan Fuzzy C-Means

K-means meminimalkan:
1. within-cluster sum of squares
2. entropy kelas
3. log-loss
4. hinge loss
K-means sensitif terhadap:
1. jumlah huruf variabel
2. inisialisasi centroid
3. urutan nama kolom saja
4. warna plot
Fuzzy C-Means berbeda dari K-means karena:
1. tidak punya pusat cluster
2. observasi boleh punya keanggotaan parsial
3. hanya untuk teks
4. wajib data kategorik
Parameter m pada FCM mengontrol:
1. banyak observasi
2. derajat kefuzzyan
3. jumlah fitur
4. jumlah fold
Elbow method biasa dipakai untuk:
1. memilih jumlah cluster
2. memilih learning rate
3. memilih kernel
4. memilih confusion matrix

16.33 Soal Pertemuan 7: Gradient Boosting

Boosting bersifat:
1. paralel penuh dari awal
2. sekuensial
3. tanpa loss function
4. tanpa tuning
Weak learner yang umum dipakai dalam boosting adalah:
1. tree kecil
2. PCA
3. k-fold
4. VIF
Learning rate pada boosting yang terlalu besar berisiko:
1. overfitting lebih cepat
2. menghapus variabel
3. mengubah target menjadi biner
4. membuat data seimbang
Pada time series, boosting dapat dipakai setelah:
1. data dihapus seluruh trennya saja
2. dibuat fitur lag
3. target diacak
4. semua data dijadikan kategorik
Baseline penting saat memakai boosting karena:
1. boosting selalu menang
2. kita perlu tahu apakah model kompleks benar-benar memberi nilai tambah
3. boosting tidak bisa dievaluasi
4. baseline hanya formalitas

16.34 Soal Pertemuan 8: UTS Project

Tujuan utama UTS project adalah:
1. menghafal rumus
2. menyusun workflow analisis utuh
3. membuat kode terpanjang
4. hanya menampilkan grafik
Baseline model wajib ada karena:
1. tanpa baseline tidak ada pembanding yang wajar
2. baseline selalu paling akurat
3. dosen melarang tuning
4. agar kode lebih pendek
Data leakage berarti:
1. data hilang
2. informasi masa depan bocor ke proses training
3. ukuran file besar
4. variabel tidak numerik
Report proyek yang baik harus:
1. hanya berisi kode
2. hanya berisi hasil akhir
3. menjelaskan data, model, evaluasi, dan interpretasi
4. tanpa kesimpulan
Metrik proyek harus dipilih berdasarkan:
1. warna slide
2. tujuan masalah dan biaya kesalahan
3. paket R favorit
4. banyaknya halaman report

16.35 Soal Pertemuan 9: Naive Bayes dan K-NN

Naive Bayes menggunakan dasar:
1. aturan pruning
2. teorema Bayes
3. gradient descent
4. bootstrap
Asumsi utama Naive Bayes adalah:
1. semua fitur identik
2. fitur saling independen bersyarat pada kelas
3. data harus seimbang sempurna
4. target harus kontinu
K-NN disebut lazy learner karena:
1. tidak pernah memprediksi
2. tidak membangun model parametrik eksplisit saat training
3. hanya untuk data kecil
4. selalu memakai k = 1
K-NN sangat sensitif terhadap:
1. nama kolom
2. urutan baris
3. skala fitur
4. warna grafik
Nilai k yang terlalu kecil cenderung:
1. terlalu halus
2. underfit berat
3. sensitif terhadap noise
4. sama saja dengan k besar

16.36 Soal Pertemuan 10: Decision Tree

Decision tree klasifikasi biasanya memilih split yang menurunkan:
1. entropy atau Gini
2. VIF
3. AIC
4. p-value
Leaf pada tree regresi biasanya berisi:
1. probabilitas posterior
2. rata-rata target dalam region
3. koefisien slope
4. eigenvalue
Pruning dilakukan untuk:
1. memperbesar kedalaman
2. menambah jumlah fitur
3. mengurangi overfitting
4. menghapus target
Decision tree tidak wajib standardisasi karena:
1. tidak berbasis jarak global
2. semua fitur otomatis normal
3. hanya untuk data kategorik
4. tidak punya hyperparameter
Single tree sering tidak stabil karena:
1. tidak memakai fitur
2. pemilihan split bersifat greedy
3. semua leaf selalu sama
4. target selalu kontinu

16.37 Soal Pertemuan 11: Random Forest

Random Forest dibangun dari:
1. satu tree sangat dalam
2. banyak tree dari bootstrap sample
3. satu model linear
4. satu model SVM
mtry pada Random Forest adalah:
1. jumlah data latih
2. jumlah fitur kandidat pada tiap split
3. jumlah kelas
4. jumlah iterasi gradient descent
OOB error diperkirakan dari:
1. data uji luar kampus
2. observasi yang tidak masuk bootstrap sample tertentu
3. data yang sudah dihapus
4. residual PCA
Random Forest biasanya lebih stabil dari single tree karena:
1. semua pohon identik
2. averaging menurunkan variance
3. tidak memakai split
4. tidak butuh data
Importance plot dipakai untuk:
1. melihat fitur yang paling berkontribusi
2. memilih jumlah observasi
3. mengubah target
4. mengukur entropy langsung

16.38 Soal Pertemuan 12: SVM

Tujuan utama SVM adalah:
1. memaksimalkan margin
2. meminimalkan Gini
3. memaksimalkan jumlah fitur
4. menambah jumlah kelas
cost pada SVM mengontrol:
1. trade-off antara margin lebar dan penalti salah klasifikasi
2. jumlah fitur aktif
3. ukuran test set
4. banyaknya cluster
Kernel radial digunakan ketika:
1. boundary linear sempurna
2. hubungan non-linear diduga kuat
3. hanya ada satu fitur
4. target kontinu wajib
Support vector adalah:
1. semua titik data
2. titik yang berada paling jauh dari boundary
3. titik yang menentukan posisi hyperplane
4. fitur dengan variance nol
Standardisasi fitur penting pada SVM karena:
1. SVM sangat dipengaruhi skala
2. SVM hanya menerima data integer
3. kernel tidak boleh dipakai
4. target harus nol satu

16.39 Soal Pertemuan 13: SVR

SVR merupakan:
1. versi regresi dari SVM
2. versi klasifikasi dari PCA
3. jenis clustering
4. teknik bootstrap
epsilon pada SVR adalah:
1. jumlah fold
2. lebar tabung toleransi error
3. jumlah fitur
4. ukuran learning rate
Kernel radial pada SVR berguna untuk:
1. hubungan non-linear
2. menormalkan data
3. mengubah target jadi biner
4. menghitung silhouette
Jika cost terlalu besar pada SVR, model cenderung:
1. lebih permisif terhadap error
2. lebih kaku terhadap error
3. berubah menjadi clustering
4. menghapus observasi
Kelebihan utama SVR dibanding regresi linear adalah:
1. selalu lebih interpretatif
2. bisa lebih fleksibel dengan kernel
3. tidak butuh data
4. tidak perlu tuning

16.40 Soal Pertemuan 14: Neural Network dan Deep Learning

Neuron buatan menghitung:
1. kombinasi linear lalu aktivasi
2. hanya rata-rata fitur
3. hanya jarak Euclidean
4. hanya confusion matrix
Fungsi aktivasi non-linear penting karena:
1. tanpa itu jaringan setara model linear berlapis
2. membuat data lebih besar
3. menghapus error
4. memilih jumlah fold
Backpropagation dipakai untuk:
1. membentuk dendrogram
2. menghitung gradien bobot
3. memilih medoid
4. mengurutkan observasi
Deep learning umumnya relevan ketika:
1. data sangat kecil dan sederhana
2. data kompleks dan representasi berlapis dibutuhkan
3. hanya ada dua observasi
4. target selalu linear
Salah satu risiko neural network adalah:
1. overfitting
2. tidak punya parameter
3. tidak bisa klasifikasi
4. tidak perlu optimisasi

16.41 Soal Pertemuan 15: Validation dan Evaluation

K-fold cross-validation bertujuan:
1. menambah fitur
2. memberi estimasi performa yang lebih stabil
3. menghapus target
4. mengubah data jadi time series
Precision dihitung sebagai:
1. TP / (TP + FN)
2. TP / (TP + FP)
3. TN / (TN + FP)
4. (TP + TN) / n khusus regresi
Recall penting ketika:
1. false negative mahal
2. false positive tidak relevan
3. target kontinu
4. jumlah fitur sedikit
RMSE dibanding MAE lebih sensitif terhadap:
1. kelas minoritas
2. outlier besar
3. jumlah fold
4. jumlah kolom
Test set sebaiknya:
1. dipakai berulang untuk tuning
2. dipakai di tahap akhir evaluasi
3. digabung ke train agar data banyak
4. dihapus jika akurasi rendah

16.42 Soal Pertemuan 16: UAS Project

Proyek UAS minimal sebaiknya membandingkan:
1. satu model saja
2. tiga model atau lebih
3. tanpa baseline
4. tanpa validasi
Kode proyek yang baik harus:
1. panjang
2. sulit dibaca
3. reprodusibel
4. tanpa komentar
Ringkasan eksekutif dibuat untuk:
1. menyulitkan pembaca
2. menyampaikan inti hasil secara cepat
3. mengganti report penuh
4. menghindari evaluasi
Keterbatasan proyek perlu ditulis agar:
1. laporan tampak lebih panjang
2. pembaca memahami ruang lingkup dan batas validitas hasil
3. model terlihat lemah
4. dosen tidak membaca kode
Model terbaik dalam UAS dipilih berdasarkan:
1. algoritma paling populer
2. ukuran file output
3. argumen teknis, evaluasi, dan relevansi masalah
4. warna visualisasi

Lampiran C: Kunci Jawaban Ringkas Bank Soal

16.43 Kunci Pertemuan 1

b, karena ML berfokus pada pembelajaran pola dari data.
c, karena ada target kontinu yang ingin diprediksi.
b, karena clustering bekerja tanpa label target.
b, karena generalisasi berarti performa baik pada data baru.
c, karena tanpa rumusan masalah model mudah salah arah.

16.44 Kunci Pertemuan 2

a, karena regresi paling umum memakai MSE.
c, itu adalah bentuk solusi OLS.
b, parameter diperbarui ke arah negatif gradien.
c, learning rate terlalu besar bisa membuat loss tidak stabil.
b, skala fitur yang seragam membantu optimisasi.

16.45 Kunci Pertemuan 3

b, Ridge memakai penalti L2.
c, penalti L1 bisa membuat koefisien nol.
b, Elastic Net berguna saat fitur berkorelasi dan seleksi dibutuhkan.
c, alpha = 0 adalah Ridge.
b, lambda.min meminimalkan error cross-validation.

16.46 Kunci Pertemuan 4

b, PCA meringkas dimensi.
b, PCA berguna saat banyak variabel saling berkorelasi.
b, eigenvalue besar berarti komponen menjelaskan varian besar.
a, analisis faktor berfokus pada faktor laten.
a, PCA sensitif pada skala karena berbasis kovarians/korelasi.

16.47 Kunci Pertemuan 5

b, hierarchical clustering menghasilkan dendrogram.
b, complete linkage memakai jarak maksimum.
a, medoid adalah observasi aktual sehingga lebih robust.
c, clustering adalah unsupervised learning.
b, jarak sangat dipengaruhi skala fitur.

16.48 Kunci Pertemuan 6

a, K-means meminimalkan within-cluster sum of squares.
b, centroid awal memengaruhi solusi akhir.
b, FCM mengizinkan keanggotaan parsial.
b, m mengontrol tingkat kefuzzyan.
a, elbow method sering dipakai untuk memilih jumlah cluster.

16.49 Kunci Pertemuan 7

b, boosting membangun model secara berurutan.
a, weak learner yang umum adalah tree kecil.
a, learning rate besar bisa mempercepat overfitting.
b, time series sering diubah menjadi fitur lag.
b, baseline diperlukan untuk menilai nilai tambah model kompleks.

16.50 Kunci Pertemuan 8

b, UTS menilai workflow utuh.
a, tanpa baseline tidak ada tolok ukur wajar.
b, leakage terjadi saat informasi masa depan bocor ke training.
c, report harus menjelaskan proses dan hasil.
b, metrik harus sesuai tujuan dan biaya kesalahan.

16.51 Kunci Pertemuan 9

b, Naive Bayes berasal dari teorema Bayes.
b, asumsi kuncinya adalah independensi bersyarat.
b, K-NN tidak membangun model parametrik saat training.
c, jarak pada K-NN sensitif terhadap skala.
c, k kecil mudah sensitif terhadap noise.

16.52 Kunci Pertemuan 10

a, tree klasifikasi menurunkan impurity seperti entropy atau Gini.
b, leaf regresi berisi rata-rata target.
c, pruning dipakai untuk mengurangi overfitting.
a, tree tidak bergantung pada jarak global antarf fitur.
b, split greedy membuat single tree kurang stabil.

16.53 Kunci Pertemuan 11

b, Random Forest membangun banyak tree dari bootstrap sample.
b, mtry adalah jumlah fitur kandidat per split.
b, OOB error dihitung dari observasi yang tidak terambil dalam bootstrap tertentu.
b, averaging banyak tree menurunkan variance.
a, importance plot menunjukkan fitur berkontribusi besar.

16.54 Kunci Pertemuan 12

a, SVM mencari margin maksimum.
a, cost menyeimbangkan margin dan penalti salah klasifikasi.
b, kernel radial cocok untuk boundary non-linear.
c, support vectors menentukan letak hyperplane.
a, skala fitur sangat mempengaruhi margin dan kernel.

16.55 Kunci Pertemuan 13

a, SVR adalah perluasan SVM ke regresi.
b, epsilon adalah tabung toleransi.
a, kernel radial menangkap hubungan non-linear.
b, cost besar membuat model kurang permisif terhadap error.
b, fleksibilitas kernel adalah keunggulan utama SVR.

16.56 Kunci Pertemuan 14

a, neuron menghitung kombinasi linear lalu aktivasi.
a, tanpa aktivasi non-linear jaringan kolaps menjadi model linear.
b, backpropagation menghitung gradien bobot.
b, deep learning relevan untuk representasi kompleks.
a, neural network rawan overfitting.

16.57 Kunci Pertemuan 15

b, k-fold memberi estimasi performa yang lebih stabil.
b, precision adalah TP per seluruh prediksi positif.
a, recall penting saat false negative mahal.
b, RMSE menghukum error besar lebih keras.
b, test set dipakai pada evaluasi akhir.

16.58 Kunci Pertemuan 16

b, proyek akhir sebaiknya membandingkan beberapa model.
c, reprodusibilitas adalah syarat dasar proyek yang baik.
b, ringkasan eksekutif menyampaikan inti hasil dengan cepat.
b, keterbatasan menunjukkan batas validitas hasil.
c, pemilihan model terbaik harus didukung argumen teknis.

Lampiran D: Checklist Praktikum, Report, dan Presentasi

16.59 Checklist Sebelum Coding

Masalah sudah dirumuskan dengan jelas.
Tipe target sudah ditetapkan dengan benar.
Metrik evaluasi sudah dipilih.
Tidak ada kebingungan antara train, validation, dan test.
Struktur folder proyek sudah dibuat.
Dataset sudah terdokumentasi sumbernya.
Variabel target tidak bocor ke fitur.
Paket R yang dibutuhkan sudah dicatat.
Seed untuk reproduksibilitas sudah ditetapkan.
Nama file dan script sudah rapi.

16.60 Checklist Saat Eksplorasi Data

Cek dimensi data.
Cek tipe setiap variabel.
Cek missing values.
Cek duplikasi observasi.
Cek distribusi target.
Cek outlier yang relevan.
Buat visualisasi dasar.
Tulis insight eksplorasi, bukan hanya tampilkan plot.
Catat potensi ketidakseimbangan kelas.
Catat potensi multikolinearitas bila relevan.

16.61 Checklist Saat Modeling

Buat baseline model dulu.
Pisahkan data train dan test dengan benar.
Lakukan preprocessing hanya berdasarkan data train jika perlu.
Simpan parameter model.
Simpan hasil prediksi.
Simpan metrik evaluasi.
Bandingkan lebih dari satu model jika tugas meminta.
Hindari tuning di test set.
Catat alasan memilih hyperparameter.
Interpretasikan hasil sementara.

16.62 Checklist Saat Evaluasi

Gunakan metrik yang sesuai dengan tujuan masalah.
Laporkan confusion matrix untuk klasifikasi bila relevan.
Laporkan RMSE atau MAE untuk regresi.
Jelaskan apakah data seimbang atau tidak.
Bandingkan train dan test performance.
Lakukan cross-validation bila perlu.
Cek apakah hasil terlalu bagus secara tidak wajar.
Jelaskan risiko overfitting atau underfitting.
Hindari hanya melaporkan satu angka tanpa konteks.
Hubungkan metrik dengan implikasi praktis.

16.63 Checklist Penulisan Report

Judul sesuai isi proyek.
Abstrak singkat dan informatif.
Latar belakang tidak terlalu umum.
Tujuan analisis eksplisit.
Sumber data jelas.
Variabel utama dijelaskan.
Proses pembersihan data ditulis.
Metode dijelaskan dengan cukup.
Hasil diberi interpretasi.
Tabel dan gambar diberi judul.
Satuan dan istilah konsisten.
Kesimpulan menjawab tujuan awal.
Keterbatasan ditulis jujur.
Referensi ditulis konsisten.
Lampiran kode disiapkan bila perlu.

16.64 Checklist Presentasi

Slide pembuka jelas.
Masalah dan tujuan tidak terlalu panjang.
Data dijelaskan singkat tapi cukup.
Visualisasi mudah dibaca.
Hasil utama ditonjolkan.
Tabel tidak terlalu padat.
Jangan menyalin seluruh output R ke slide.
Sampaikan satu pesan utama per slide.
Jelaskan model terbaik dan alasannya.
Siapkan jawaban untuk pertanyaan validasi, leakage, dan keterbatasan.

16.65 Rubrik Presentasi yang Disarankan

Aspek	Indikator
Kejelasan masalah	audiens paham apa yang dianalisis
Kualitas data	sumber dan kualitas data dijelaskan
Metodologi	model dan evaluasi dijelaskan benar
Hasil	metrik dan interpretasi konsisten
Komunikasi	slide rapi dan penjelasan lugas
Pertanyaan	mampu mempertahankan keputusan teknis

16.66 Pertanyaan Umum dari Penguji

Mengapa Anda memilih model itu?
Mengapa metrik evaluasi itu yang dipakai?
Bagaimana Anda memastikan tidak ada data leakage?
Apa baseline model Anda?
Mengapa model A lebih baik dari model B?
Apakah hasil bisa digeneralisasi?
Apa keterbatasan data?
Jika waktu tambahan diberikan, apa yang akan Anda perbaiki?

16.67 Template Narasi Presentasi

Masalah yang kami angkat adalah …
Tujuan analisis kami adalah …
Dataset kami berasal dari …
Variabel target kami adalah …
Model baseline kami adalah …
Model pembanding kami adalah …
Metrik evaluasi kami adalah …
Hasil terbaik diperoleh oleh …
Alasan kami memilih model akhir adalah …
Keterbatasan utama studi ini adalah …

Lampiran E: Bank Tugas Pemrograman R per Pertemuan

16.68 Tugas R Pertemuan 1

Muat iris, mtcars, dan USArrests.
Tulis dimensi setiap dataset.
Tentukan tipe target yang mungkin untuk tiap dataset.
Buat train-test split sederhana untuk iris.
Tampilkan proporsi kelas pada train dan test.
Buat satu tabel yang menjelaskan tipe masalah tiap dataset.
Tulis satu paragraf tentang perbedaan supervised dan unsupervised learning.
Tulis satu paragraf tentang pentingnya generalisasi.
Simpan skrip dengan nama yang rapi.
Tambahkan komentar singkat pada setiap blok kode.

16.69 Tugas R Pertemuan 2

Bangun model lm() untuk mpg ~ wt + hp.
Simpan koefisien model.
Hitung prediksi pada data mtcars.
Hitung RMSE.
Implementasikan gradient descent manual.
Simpan history loss.
Plot loss versus epoch.
Uji dua learning rate tambahan.
Bandingkan koefisien OLS dan gradient descent.
Tulis interpretasi hasilnya.

16.70 Tugas R Pertemuan 3

Buat matriks desain dari mtcars.
Jalankan Ridge dengan cv.glmnet.
Jalankan Lasso dengan cv.glmnet.
Jalankan Elastic Net dengan alpha = 0.5.
Simpan lambda.min tiap model.
Ekstrak koefisien akhir tiap model.
Identifikasi koefisien nol pada Lasso.
Hitung RMSE tiap model.
Bandingkan dengan OLS.
Tulis refleksi kapan tiap metode cocok.

16.71 Tugas R Pertemuan 4

Standarkan USArrests.
Jalankan prcomp().
Tampilkan proporsi variasi.
Buat scree plot.
Buat biplot.
Jalankan factanal() dengan satu faktor jika memakai USArrests.
Tampilkan factor loadings.
Bandingkan hasil PCA dan analisis faktor.
Tulis interpretasi komponen pertama.
Tulis interpretasi faktor pertama.

16.72 Tugas R Pertemuan 5

Hitung jarak Euclidean pada USArrests.
Bangun dendrogram complete linkage.
Bangun dendrogram average linkage.
Bangun dendrogram Ward linkage.
Potong masing-masing dendrogram pada k = 3.
Bandingkan hasil cluster.
Jalankan pam() dengan k = 3.
Hitung silhouette width.
Tulis karakter tiap cluster.
Buat kesimpulan metode mana yang lebih mudah dijelaskan.

16.73 Tugas R Pertemuan 6

Standarkan fitur iris.
Jalankan K-means dengan centers = 3.
Ulangi dengan nstart = 1, 10, dan 25.
Bandingkan hasil cluster.
Buat tabel cluster versus Species.
Jalankan Fuzzy C-Means.
Tampilkan membership untuk 10 observasi pertama.
Identifikasi observasi dengan membership paling ambigu.
Bandingkan K-means dan FCM.
Tulis refleksi kapan pendekatan fuzzy lebih masuk akal.

16.74 Tugas R Pertemuan 7

Bangun model gbm untuk mtcars.
Simpan importance summary.
Pilih jumlah tree terbaik.
Hitung RMSE pada data yang dipilih.
Bentuk data lag untuk AirPassengers.
Bagi menjadi train dan test.
Bangun boosting time series.
Hitung RMSE test.
Bandingkan dengan model baseline sederhana.
Tulis interpretasi hasil.

16.75 Tugas R Pertemuan 8

Pilih dataset proyek.
Tulis skrip untuk membaca data.
Buat data dictionary sederhana.
Tentukan target dan fitur kandidat.
Pisahkan train dan test jika relevan.
Buat baseline model.
Buat satu model pembanding.
Hitung metrik utama.
Simpan seluruh output penting dalam folder proyek.
Tulis proposal singkat 1 halaman.

16.76 Tugas R Pertemuan 9

Bagi iris menjadi train dan test.
Jalankan Naive Bayes.
Hitung confusion matrix Naive Bayes.
Standardisasi fitur train dan test untuk K-NN.
Jalankan K-NN dengan k = 3.
Jalankan K-NN dengan k = 5.
Jalankan K-NN dengan k = 7.
Buat tabel perbandingan akurasi.
Simpan prediksi tiap model.
Tulis kesimpulan model mana yang paling baik dan mengapa.

16.77 Tugas R Pertemuan 10

Bangun decision tree klasifikasi pada iris.
Plot tree awal.
Tampilkan printcp().
Pilih cp terbaik.
Lakukan pruning.
Hitung confusion matrix.
Bangun tree regresi pada mtcars.
Hitung RMSE dan MAE.
Ekstrak aturan utama pohon.
Tulis interpretasi lima aturan terpenting.

16.78 Tugas R Pertemuan 11

Jalankan Random Forest pada iris.
Simpan OOB error.
Uji ntree = 100, 300, 500.
Uji beberapa nilai mtry.
Catat perubahan OOB error.
Tampilkan importance plot.
Simpan confusion matrix jika tersedia.
Bandingkan dengan decision tree tunggal.
Tulis fitur paling penting.
Tulis alasan mengapa Random Forest lebih stabil.

16.79 Tugas R Pertemuan 12

Bentuk dataset biner dari iris.
Split data menjadi train dan test.
Jalankan SVM linear.
Jalankan SVM radial.
Bandingkan akurasi.
Uji dua nilai cost.
Uji dua nilai gamma untuk radial.
Simpan confusion matrix.
Tulis interpretasi hasil kernel linear.
Tulis interpretasi hasil kernel radial.

16.80 Tugas R Pertemuan 13

Bagi mtcars menjadi train dan test.
Bangun regresi linear sebagai baseline.
Bangun SVR linear.
Bangun SVR radial.
Uji dua nilai epsilon.
Uji dua nilai cost.
Hitung RMSE tiap model.
Simpan hasil dalam tabel.
Tulis kapan SVR lebih bermanfaat.
Tulis trade-off interpretasi versus fleksibilitas.

16.81 Tugas R Pertemuan 14

Bagi iris menjadi train dan test.
Bangun nnet() dengan size = 3.
Ulangi dengan size = 5.
Ulangi dengan size = 7.
Hitung akurasi tiap model.
Simpan confusion matrix.
Uji dua nilai decay.
Buat tabel perbandingan akurasi.
Bandingkan dengan satu model klasik.
Tulis refleksi kelebihan dan keterbatasan neural network kecil.

16.82 Tugas R Pertemuan 15

Bangun satu model klasifikasi sederhana.
Hitung confusion matrix.
Hitung accuracy.
Hitung precision.
Hitung recall.
Hitung F1-score.
Lakukan 5-fold cross-validation sederhana.
Bandingkan hasil single split dan k-fold.
Ulangi pada satu model regresi dan hitung MAE serta RMSE.
Tulis alasan memilih metrik yang Anda gunakan.

16.83 Tugas R Pertemuan 16

Rapikan folder proyek akhir.
Pastikan semua script dapat dijalankan dari awal.
Buat file README singkat.
Finalisasi data dictionary.
Simpan semua output model utama.
Buat tabel perbandingan model.
Tulis ringkasan eksekutif 1 halaman.
Finalisasi report akhir.
Finalisasi slide presentasi.
Siapkan daftar kemungkinan pertanyaan dari penguji.

Lampiran F: FAQ dan Kesalahan Umum

16.84 FAQ Umum

Apakah machine learning selalu lebih baik dari statistika klasik?
Tidak. Pilihan metode harus mengikuti tujuan analisis, struktur data, dan kebutuhan interpretasi.
Apakah akurasi tinggi selalu berarti model bagus?
Tidak. Pada data tidak seimbang, akurasi bisa menyesatkan.
Apakah train error yang kecil berarti model siap dipakai?
Tidak. Yang penting adalah performa out-of-sample.
Mengapa baseline model wajib dibuat?
Karena model kompleks harus dibuktikan memberi nilai tambah, bukan diasumsikan selalu unggul.
Apakah semua fitur harus distandardisasi?
Tidak. Tergantung metode. K-NN, SVM, dan PCA sangat membutuhkannya, sedangkan tree tidak selalu.
Mengapa cross-validation sering dipakai?
Karena ia memberi estimasi performa yang lebih stabil dibanding satu split tunggal.
Apakah model paling kompleks selalu terbaik?
Tidak. Kompleksitas berlebih bisa meningkatkan variance.
Apa beda validation set dan test set?
Validation set untuk tuning, test set untuk evaluasi akhir.
Apa itu data leakage?
Kebocoran informasi dari masa depan atau dari target ke proses training.
Mengapa interpretasi model penting?
Karena keputusan nyata sering memerlukan penjelasan yang dapat dipertanggungjawabkan.

16.85 Kesalahan Umum Saat Belajar

Salah memilih tipe masalah.
Mahasiswa kadang mengerjakan clustering untuk masalah yang sebenarnya klasifikasi.
Tidak membedakan fitur dan target.
Ini membuat workflow kacau sejak awal.
Langsung memakai model paling rumit.
Kebiasaan ini membuat evaluasi tidak disiplin.
Mengabaikan eksplorasi data.
Akibatnya model dibangun tanpa memahami struktur data.
Tidak memeriksa missing values.
Hasil model bisa salah atau gagal dijalankan.
Tidak memeriksa ketidakseimbangan kelas.
Ini membuat accuracy kelihatan bagus padahal model gagal menangkap kelas minoritas.
Melakukan scaling sebelum split.
Ini bisa memicu leakage ringan.
Menggunakan test set untuk tuning.
Ini merusak validitas evaluasi.
Melaporkan angka tanpa interpretasi.
Hasil menjadi miskin makna.
Terlalu fokus pada satu metrik.
Kadang precision, recall, dan F1 jauh lebih relevan.

16.86 FAQ Khusus Metode

Mengapa Ridge tidak menghilangkan fitur?
Karena penalti L2 menyusutkan koefisien tanpa mendorong nol secara keras.
Mengapa Lasso bisa tidak stabil saat fitur sangat berkorelasi?
Karena ia bisa memilih salah satu fitur secara arbitrer.
Mengapa PCA bukan metode klasifikasi?
Karena PCA mereduksi dimensi, bukan memprediksi kelas.
Apakah cluster selalu punya label benar?
Tidak. Clustering lebih bersifat eksploratif.
Mengapa K-means sensitif pada outlier?
Karena pusat cluster berbasis rata-rata.
Mengapa FCM berguna?
Karena beberapa observasi memang berada pada batas antarcluster.
Mengapa boosting perlu tuning hati-hati?
Karena model sangat fleksibel dan bisa overfit.
Mengapa Naive Bayes bisa tetap bagus walau asumsi independensi tidak realistis?
Karena klasifikasi sering masih bekerja baik meski asumsi tidak sempurna.
Mengapa K-NN butuh scaling?
Karena ia memakai jarak antarf titik.
Mengapa decision tree mudah dijelaskan?
Karena output-nya berupa aturan if-then yang eksplisit.
Mengapa single tree tidak stabil?
Karena split awal sangat mempengaruhi seluruh struktur berikutnya.
Mengapa Random Forest sering lebih akurat?
Karena banyak tree menurunkan variance.
Mengapa SVM kuat pada data berdimensi menengah sampai tinggi?
Karena margin maksimum dan kernel dapat membentuk boundary kuat.
Mengapa SVR menarik?
Karena ia membawa fleksibilitas SVM ke masalah regresi.
Mengapa neural network butuh banyak tuning?
Karena banyak parameter dan arsitektur mempengaruhi hasil.

16.87 FAQ Proyek

Berapa banyak model yang sebaiknya dibandingkan?
Minimal satu baseline dan satu atau dua model pembanding yang relevan.
Apakah visualisasi harus banyak?
Tidak. Yang penting informatif dan mendukung argumen.
Apakah report harus panjang?
Tidak. Yang penting jelas, logis, dan lengkap.
Apakah semua output R perlu ditempel ke report?
Tidak. Pilih output yang penting.
Apa yang harus dilakukan jika dua model punya akurasi mirip?
Pertimbangkan stabilitas, interpretasi, dan biaya implementasi.
Bagaimana jika model terbaik sulit dijelaskan?
Jelaskan hasilnya, bandingkan dengan model interpretable, dan tulis trade-off secara jujur.
Apakah dataset kecil masih boleh dipakai?
Boleh, tetapi batasi klaim dan gunakan evaluasi yang hati-hati.
Apa yang harus dilakukan jika data sangat kotor?
Dokumentasikan proses cleaning dan jelaskan keterbatasan data.
Apakah boleh memakai data sintetis?
Boleh untuk pembelajaran metode, tetapi proyek utama sebaiknya memakai data nyata.
Bagaimana memilih topik proyek?
Pilih masalah yang datanya tersedia, targetnya jelas, dan bisa dievaluasi.
Mengapa reproducibility penting?
Karena hasil harus dapat diulangi oleh orang lain.
Apakah perlu menyimpan seed?
Ya, terutama untuk split acak dan model stokastik.
Bagaimana jika hasil antar-run berbeda?
Catat seed, lakukan pengulangan, dan laporkan variabilitas bila perlu.
Apa yang harus ditulis pada bagian keterbatasan?
Keterbatasan data, metode, asumsi, dan ruang lingkup generalisasi.
Apa ciri proyek machine learning yang matang?
Masalah jelas, data rapi, evaluasi benar, interpretasi konsisten, dan kode reprodusibel.

Lampiran G: Glosarium Istilah Machine Learning

16.87.1 Accuracy

Proporsi prediksi yang benar dari seluruh observasi. Catatan: berguna jika kelas relatif seimbang.

16.87.2 Activation Function

Fungsi non-linear yang diterapkan pada output neuron. Catatan: contoh umum adalah sigmoid, tanh, dan ReLU.

16.87.3 AdaBoost

Metode boosting yang menekankan observasi yang salah diprediksi pada iterasi sebelumnya. Catatan: salah satu ensemble klasik.

16.87.4 Algorithm

Serangkaian langkah sistematis untuk menyelesaikan masalah. Catatan: dalam ML, algoritma biasanya mengoptimalkan loss tertentu.

16.87.5 AUC

Area under ROC curve untuk mengukur kemampuan model membedakan kelas. Catatan: sering dipakai pada klasifikasi biner.

16.87.6 Backpropagation

Prosedur menghitung gradien pada neural network dengan aturan rantai. Catatan: fondasi training deep learning.

16.87.7 Bagging

Bootstrap aggregating yang menggabungkan banyak model dari bootstrap sample. Catatan: Random Forest dibangun di atas prinsip ini.

16.87.8 Baseline Model

Model acuan sederhana yang dipakai sebagai pembanding awal. Catatan: wajib ada pada proyek yang disiplin.

16.87.9 Batch

Sekelompok observasi yang diproses bersama saat training. Catatan: umum pada gradient-based learning.

16.87.10 Bias

Komponen error karena model terlalu sederhana atau terlalu kaku. Catatan: bias tinggi sering terkait underfitting.

16.87.11 Binary Classification

Masalah klasifikasi dengan dua kelas. Catatan: contoh umum adalah ya/tidak atau fraud/tidak.

16.87.12 Biplot

Visualisasi PCA yang menampilkan observasi dan loading komponen sekaligus. Catatan: berguna untuk interpretasi awal.

16.87.13 Bootstrap Sample

Sampel acak dengan pengembalian dari data asli. Catatan: dipakai pada bagging dan Random Forest.

16.87.14 CART

Classification and Regression Trees. Catatan: algoritma pohon biner yang sangat populer.

16.87.15 Centroid

Pusat cluster pada K-means. Catatan: dihitung sebagai rata-rata anggota cluster.

16.87.16 Class Imbalance

Kondisi saat distribusi kelas sangat tidak seimbang. Catatan: accuracy sering menyesatkan pada kondisi ini.

16.87.17 Classification

Masalah prediksi kategori. Catatan: target berbentuk label atau kelas.

16.87.18 Cluster

Kelompok observasi yang mirip satu sama lain. Catatan: hasil cluster tidak selalu unik.

16.87.19 Confusion Matrix

Tabel silang antara kelas aktual dan prediksi. Catatan: dasar perhitungan accuracy, precision, recall, dan F1.

16.87.20 Cost

Parameter regularisasi pada SVM/SVR. Catatan: mengontrol penalti kesalahan.

16.87.21 Cross-Validation

Teknik evaluasi dengan membagi data ke beberapa fold. Catatan: memberi estimasi performa lebih stabil.

16.87.22 Data Leakage

Kebocoran informasi yang seharusnya tidak tersedia saat training. Catatan: harus dihindari.

16.87.23 Data Mining

Proses menemukan pola berguna dari data. Catatan: machine learning adalah salah satu komponennya.

16.87.24 Deep Learning

Pembelajaran dengan neural network berlapis banyak. Catatan: sangat kuat untuk data tidak terstruktur.

16.87.25 Decision Boundary

Batas yang memisahkan kelas dalam ruang fitur. Catatan: bentuknya tergantung model.

16.87.26 Decision Tree

Model berbasis aturan if-then yang membagi ruang fitur secara bertingkat. Catatan: sangat interpretatif.

16.87.27 Dimensionality Reduction

Teknik mengurangi jumlah variabel efektif. Catatan: contoh utamanya PCA.

16.87.28 Distance Metric

Ukuran kedekatan antarobservasi. Catatan: Euclidean dan Manhattan adalah contoh umum.

16.87.29 Elastic Net

Regularisasi gabungan L1 dan L2. Catatan: cocok saat fitur berkorelasi.

16.87.30 Ensemble Learning

Strategi menggabungkan banyak model untuk meningkatkan performa. Catatan: bagging dan boosting adalah contoh utama.

16.87.31 Entropy

Ukuran impurity yang berasal dari teori informasi. Catatan: dipakai pada split decision tree.

16.87.32 Epoch

Satu putaran penuh melalui seluruh data training. Catatan: umum pada optimisasi neural network.

16.87.33 Epsilon

Lebar tabung toleransi error pada SVR. Catatan: error kecil di dalam tabung tidak dihukum.

16.87.34 Evaluation Metric

Ukuran kuantitatif untuk menilai performa model. Catatan: harus sesuai tujuan masalah.

16.87.35 Factor Analysis

Metode untuk memodelkan konstruk atau faktor laten. Catatan: berbeda dari PCA.

16.87.36 Feature

Variabel input yang dipakai model. Catatan: disebut juga prediktor atau atribut.

16.87.37 Feature Engineering

Proses merancang atau mentransformasi fitur agar model lebih efektif. Catatan: penting pada banyak proyek praktis.

16.87.38 F1-Score

Rata-rata harmonik precision dan recall. Catatan: berguna untuk data tidak seimbang.

16.87.39 Fold

Satu bagian data dalam cross-validation. Catatan: tiap fold bergantian menjadi validation set.

16.87.40 Fuzzy C-Means

Metode clustering yang memberi derajat keanggotaan parsial. Catatan: cocok untuk batas cluster yang kabur.

16.87.41 Gamma

Parameter kernel radial pada SVM/SVR. Catatan: mengontrol kelokalan pengaruh observasi.

16.87.42 Generalization

Kemampuan model bekerja baik pada data baru. Catatan: inti utama machine learning.

16.87.43 Gini Index

Ukuran impurity yang umum dipakai pada CART. Catatan: alternatif entropy.

16.87.44 Gradient

Vektor turunan parsial loss terhadap parameter. Catatan: menentukan arah pembaruan parameter.

16.87.45 Gradient Boosting

Boosting yang membangun model berdasarkan arah negative gradient dari loss. Catatan: sangat kuat untuk banyak tugas prediksi.

16.87.46 Gradient Descent

Algoritma optimisasi iteratif berbasis gradien. Catatan: dipakai dari regresi sampai deep learning.

16.87.47 Hold-Out

Strategi evaluasi dengan satu kali split train-test. Catatan: sederhana tetapi bisa kurang stabil.

16.87.48 Hyperparameter

Parameter yang ditetapkan pengguna sebelum training. Catatan: berbeda dari parameter model yang dipelajari.

16.87.49 Impurity

Ukuran ketidakmurnian kelas dalam node decision tree. Catatan: contoh umum adalah entropy dan Gini.

16.87.50 Information Gain

Penurunan entropy akibat suatu split. Catatan: dipakai untuk memilih split terbaik.

16.87.51 Input Layer

Lapisan pertama neural network yang menerima fitur. Catatan: tidak melakukan prediksi akhir sendiri.

16.87.52 Intercept

Konstanta dalam model regresi atau model linear. Catatan: sering ditulis \(\beta_0\).

16.87.53 Iteration

Satu langkah pembaruan parameter. Catatan: banyak algoritma berjalan iteratif.

16.87.54 K-Fold Cross-Validation

Cross-validation dengan membagi data menjadi \(K\) bagian. Catatan: salah satu prosedur evaluasi paling umum.

16.87.55 K-Means

Metode clustering berbasis centroid. Catatan: cepat dan populer untuk data numerik.

16.87.56 K-Medoids

Metode clustering berbasis medoid. Catatan: lebih robust terhadap outlier dibanding K-means.

16.87.57 K-Nearest Neighbors

Metode prediksi berdasarkan tetangga terdekat. Catatan: termasuk lazy learner.

16.87.58 Kernel

Fungsi untuk memetakan atau mengukur kemiripan di ruang fitur yang lebih tinggi. Catatan: inti kekuatan SVM non-linear.

16.87.59 Lag

Nilai masa lalu dari sebuah deret waktu. Catatan: fitur penting pada forecasting berbasis ML.

16.87.60 Lambda

Parameter regularisasi pada Ridge, Lasso, dan Elastic Net. Catatan: mengontrol besar penalti.

16.87.61 Lasso

Regresi dengan penalti L1. Catatan: dapat melakukan seleksi fitur.

16.87.62 Latent Variable

Variabel yang tidak diukur langsung tetapi diasumsikan memengaruhi variabel teramati. Catatan: konsep inti analisis faktor.

16.87.63 Leaf

Node terminal pada decision tree. Catatan: berisi prediksi akhir.

16.87.64 Learning Rate

Ukuran langkah dalam pembaruan parameter. Catatan: terlalu besar bisa tidak stabil, terlalu kecil bisa lambat.

16.87.65 Linear Model

Model yang menghubungkan input dan output secara linear dalam parameter. Catatan: regresi linear adalah contoh utamanya.

16.87.66 Loss Function

Fungsi yang mengukur kesalahan prediksi model. Catatan: training umumnya meminimalkan loss.

16.87.67 MAE

Mean absolute error. Catatan: lebih robust terhadap outlier daripada RMSE.

16.87.68 Margin

Jarak antara hyperplane dan observasi terdekat pada SVM. Catatan: SVM berusaha memaksimalkan margin.

16.87.69 Medoid

Observasi representatif yang menjadi pusat cluster pada K-medoids. Catatan: berbeda dari centroid yang berupa rata-rata.

16.87.70 Mini-Batch

Sebagian kecil data yang dipakai per langkah training. Catatan: umum pada deep learning.

16.87.71 Misclassification Error

Ukuran impurity sederhana berbasis proporsi kelas mayoritas. Catatan: kurang sensitif untuk split awal dibanding Gini atau entropy.

16.87.72 Model

Representasi matematis atau algoritmik dari hubungan data. Catatan: model dipakai untuk prediksi atau pemahaman pola.

16.87.73 Multiclass Classification

Klasifikasi dengan lebih dari dua kelas. Catatan: contoh klasik adalah dataset iris.

16.87.74 Multicollinearity

Korelasi tinggi antarfitur. Catatan: masalah ini memotivasi regularisasi pada regresi.

16.87.75 Naive Bayes

Klasifikasi probabilistik berbasis teorema Bayes dan asumsi independensi bersyarat. Catatan: sangat populer untuk data teks.

16.87.76 Neural Network

Model berlapis yang tersusun dari neuron-neuron buatan. Catatan: sangat fleksibel tetapi butuh tuning.

16.87.77 Node

Simpul dalam struktur tree. Catatan: bisa berupa root, internal, atau leaf.

16.87.78 Non-Linear

Hubungan yang tidak dapat dijelaskan dengan garis lurus sederhana. Catatan: banyak model ML unggul pada pola ini.

16.87.79 Objective Function

Fungsi yang dioptimalkan saat training. Catatan: sering sama atau sangat dekat dengan loss function.

16.87.80 One-Hot Encoding

Representasi variabel kategorik menjadi kolom indikator. Catatan: umum diperlukan pada model tertentu.

16.87.81 Out-of-Bag Error

Estimasi error pada Random Forest dari observasi yang tidak masuk bootstrap sample tertentu. Catatan: mengurangi kebutuhan validation set terpisah.

16.87.82 Outlier

Observasi ekstrem yang berbeda jauh dari sebagian besar data. Catatan: dapat memengaruhi model secara berbeda tergantung metodenya.

16.87.83 Overfitting

Kondisi saat model terlalu menyesuaikan data latih. Catatan: generalisasi ke data baru menjadi buruk.

16.87.84 PCA

Principal component analysis. Catatan: metode utama reduksi dimensi linier.

16.87.85 Parameter

Nilai internal model yang dipelajari dari data. Catatan: berbeda dari hyperparameter.

16.87.86 Partition

Pembagian ruang fitur menjadi bagian-bagian tertentu. Catatan: decision tree bekerja dengan partisi bertingkat.

16.87.87 Pipeline

Rangkaian langkah analisis dari data mentah sampai evaluasi atau deployment. Catatan: penting untuk workflow yang rapi.

16.87.88 Precision

Proporsi prediksi positif yang benar. Catatan: penting saat false positive mahal.

16.87.89 Prediction

Output yang dihasilkan model untuk observasi baru. Catatan: bisa berupa nilai, kelas, atau probabilitas.

16.87.90 Predictor

Variabel input dalam model. Catatan: sinonim dengan fitur atau kovariat.

16.87.91 Preprocessing

Tahap pembersihan dan persiapan data sebelum modeling. Catatan: termasuk scaling, encoding, dan handling missing values.

16.87.92 Pruning

Proses memotong cabang tree agar lebih sederhana dan stabil. Catatan: penting pada single tree.

16.87.93 Random Forest

Ensemble banyak decision tree dengan bootstrap dan random feature selection. Catatan: sangat kuat sebagai baseline.

16.87.94 Recall

Proporsi kelas positif aktual yang berhasil ditangkap model. Catatan: penting saat false negative mahal.

16.87.95 Regression

Masalah prediksi target kontinu. Catatan: contoh target adalah harga atau jumlah.

16.87.96 Regularization

Penambahan penalti untuk mengontrol kompleksitas model. Catatan: membantu mencegah overfitting.

16.87.97 ReLU

Rectified linear unit. Catatan: fungsi aktivasi populer pada deep learning.

16.87.98 Residual

Selisih antara nilai aktual dan prediksi. Catatan: analisis residual penting pada regresi.

16.87.99 Ridge

Regresi dengan penalti L2. Catatan: efektif untuk multikolinearitas.

16.87.100 RMSE

Root mean squared error. Catatan: menghukum error besar lebih kuat daripada MAE.

16.87.101 ROC Curve

Kurva trade-off true positive rate dan false positive rate. Catatan: sering dipakai untuk klasifikasi biner.

16.87.102 Root Node

Node pertama pada decision tree. Catatan: split awal biasanya sangat menentukan.

16.87.103 Rule Extraction

Proses mengambil aturan if-then dari model tree. Catatan: berguna untuk komunikasi hasil.

16.87.104 Scaling

Penyesuaian skala variabel input. Catatan: penting untuk metode berbasis jarak atau margin.

16.87.105 Scree Plot

Plot eigenvalue atau proporsi varian pada PCA. Catatan: membantu memilih jumlah komponen.

16.87.106 Seed

Nilai awal untuk generator bilangan acak. Catatan: penting untuk reproducibility.

16.87.107 Semi-Supervised Learning

Pembelajaran dengan sebagian data berlabel dan sebagian tidak. Catatan: berguna saat label mahal.

16.87.108 Sensitivity

Istilah lain untuk recall pada klasifikasi biner. Catatan: sering dipakai di bidang medis.

16.87.109 Silhouette

Ukuran kualitas clustering berbasis kekompakan dan pemisahan cluster. Catatan: makin besar biasanya makin baik.

16.87.110 Soft Margin

Versi SVM yang mengizinkan beberapa pelanggaran margin. Catatan: lebih realistis untuk data nyata.

16.87.111 Split

Aturan pemisahan node dalam decision tree. Catatan: dipilih untuk menurunkan impurity atau error.

16.87.112 Standardization

Transformasi agar fitur memiliki mean nol dan simpangan baku satu. Catatan: sangat penting untuk PCA, K-NN, dan SVM.

16.87.113 Stochastic Gradient Descent

Gradient descent yang memperbarui parameter dengan sebagian kecil data. Catatan: umum pada dataset besar.

16.87.114 Support Vector

Observasi yang menentukan posisi hyperplane pada SVM. Catatan: tidak semua titik data menjadi support vector.

16.87.115 Support Vector Machine

Metode klasifikasi berbasis margin maksimum. Catatan: dapat diperluas dengan kernel.

16.87.116 Support Vector Regression

Versi regresi dari SVM. Catatan: memakai epsilon-insensitive loss.

16.87.117 Supervised Learning

Pembelajaran dengan input dan target berlabel. Catatan: mencakup regresi dan klasifikasi.

16.87.118 Surrogate Split

Split pengganti saat variabel utama pada node memiliki nilai hilang. Catatan: tersedia pada beberapa implementasi tree.

16.87.119 Test Set

Bagian data yang disimpan untuk evaluasi akhir. Catatan: tidak boleh dipakai untuk tuning.

16.87.120 Threshold

Nilai batas untuk membuat keputusan atau split. Catatan: muncul pada tree dan klasifikasi probabilistik.

16.87.121 Time Series

Data yang terurut menurut waktu. Catatan: perlu perhatian pada lag, tren, dan musim.

16.87.122 Train Set

Bagian data yang dipakai melatih model. Catatan: menjadi basis belajar parameter.

16.87.123 Tuning

Proses memilih hyperparameter terbaik. Catatan: biasanya memakai validation set atau cross-validation.

16.87.124 Unsupervised Learning

Pembelajaran tanpa label target. Catatan: clustering dan reduksi dimensi adalah contoh umum.

16.87.125 Underfitting

Kondisi saat model terlalu sederhana untuk menangkap pola data. Catatan: biasanya terkait bias tinggi.

16.87.126 Validation Set

Bagian data untuk memilih model atau hyperparameter. Catatan: berbeda dari test set.

16.87.127 Variance

Komponen error karena model terlalu sensitif terhadap data latih. Catatan: variance tinggi sering terkait overfitting.

16.87.128 Variable Importance

Ukuran kontribusi fitur dalam model tertentu. Catatan: umum dilaporkan pada model tree-based.

16.87.129 Weak Learner

Model sederhana yang performanya sedikit lebih baik dari tebakan acak. Catatan: boosting menggabungkan banyak weak learner.

16.87.130 Weight Decay

Bentuk regularisasi pada neural network. Catatan: konsepnya serupa penalti L2.

16.87.131 Within-Cluster Sum of Squares

Jumlah kuadrat jarak dalam cluster. Catatan: objective function utama K-means.

Referensi Inti

James, G., Witten, D., Hastie, T., and Tibshirani, R. An Introduction to Statistical Learning.
Hastie, T., Tibshirani, R., and Friedman, J. The Elements of Statistical Learning.
Kuhn, M., and Johnson, K. Applied Predictive Modeling.
Kuhn, M., and Silge, J. Tidy Modeling with R.
Bishop, C. M. Pattern Recognition and Machine Learning.
Géron, A. Hands-On Machine Learning.
Dokumentasi paket R: glmnet, cluster, e1071, rpart, randomForest, gbm, dan nnet.

Penutup

Struktur ebook ini sengaja dibuat bertahap: mulai dari fondasi, lalu ke metode yang makin kompleks, dan ditutup dengan evaluasi serta proyek. Dengan alur ini, pembaca tidak hanya menghafal algoritma, tetapi memahami alasan kapan dan mengapa sebuah metode dipakai.

Ebook Machine Learning dengan R

Definisi, Formulasi, Implementasi, Tugas, dan Kuis

I Gede Nyoman Mindra Jaya dan Irlandia Ginanjar

08 March 2026

Prakata

Cara Menggunakan Ebook Ini

0.1 Sasaran Pembaca

0.2 Capaian Akhir Mata Kuliah

0.3 Persiapan Paket R

0.4 Notasi yang Dipakai

Peta Buku

1 Perkenalan Machine Learning

1.1 Tujuan Pembelajaran

1.2 Definisi dan Intuisi

1.3 Jenis Masalah Machine Learning

1.3.1 Supervised Learning

1.3.2 Unsupervised Learning

1.3.3 Semi-Supervised Learning

1.3.4 Reinforcement Learning

1.4 Pipeline Dasar Machine Learning

1.5 Machine Learning vs Statistik Klasik

1.6 Contoh R: Split Data Sederhana

1.7 Tugas

1.8 Kuis Singkat

1.9 Ringkasan

2 Analisis Regresi dan Gradient Descent

2.1 Tujuan Pembelajaran

2.2 Regresi Linear sebagai Fondasi

2.3 Fungsi Loss

2.4 Solusi OLS

2.5 Gradient Descent

2.6 Kapan Gradient Descent Dipakai?

2.7 Contoh R: Regresi Linear dengan lm()

2.8 Contoh R: Gradient Descent Manual

2.9 Interpretasi

2.10 Tugas

2.11 Kuis Singkat

2.12 Ringkasan

3 Ridge, Lasso, dan Elastic Net

3.1 Tujuan Pembelajaran

3.2 Mengapa Regularisasi Penting?

3.3 Ridge Regression

3.4 Lasso Regression

3.5 Elastic Net

3.6 Intuisi Geometris

3.7 Contoh R: Ridge, Lasso, Elastic Net dengan glmnet

3.8 Hal Praktis yang Perlu Diingat

3.9 Tugas

3.10 Kuis Singkat

3.11 Ringkasan

4 Reduksi Dimensi: PCA dan Analisis Faktor

4.1 Tujuan Pembelajaran

4.2 Mengapa Reduksi Dimensi?

4.3 Principal Component Analysis

4.4 Analisis Faktor

4.5 Perbedaan PCA vs Analisis Faktor

4.6 Contoh R: PCA

4.7 Contoh R: Analisis Faktor

4.8 Panduan Interpretasi

4.9 Tugas

4.10 Kuis Singkat

4.11 Ringkasan

5 Unsupervised Learning I: Hierarchical Clustering dan K-Medoids

5.1 Tujuan Pembelajaran

5.2 Konsep Clustering

5.3 Ukuran Jarak

5.4 Hierarchical Clustering

5.5 K-Medoids

5.6 Contoh R: Hierarchical Clustering

5.7 Contoh R: K-Medoids dengan pam()

5.8 Evaluasi Clustering

5.9 Tugas

5.10 Kuis Singkat

5.11 Ringkasan

6 Unsupervised Learning II: K-Means dan Fuzzy C-Means

6.1 Tujuan Pembelajaran

6.2 K-Means

6.3 Kelebihan dan Kelemahan K-Means

6.4 Fuzzy C-Means

6.5 Update Rule FCM

2.7 Contoh R: Regresi Linear dengan `lm()`

3.7 Contoh R: Ridge, Lasso, Elastic Net dengan `glmnet`

5.7 Contoh R: K-Medoids dengan `pam()`