Support Vector Machine (SVM) in R
Disusun untuk Program Studi S2 Statistika Terapan
I Gede Nyoman Mindra Jaya, Ph.D
2025-05-13
Penemu SVR
1 Support Vector Machine (SVM)
1.1 Apa Itu SVM?
Support Vector Machine (SVM) merupakan algoritma pembelajaran mesin terawasi yang digunakan untuk melakukan klasifikasi data. Prinsip kerja SVM adalah dengan mencari sebuah garis atau hyperplane optimal yang memisahkan kelas-kelas dalam data, sambil memaksimalkan jarak atau margin antar kelas tersebut dalam ruang berdimensi-N (Cortes & Vapnik, 1995).
1.2 Sejarah Singkat
SVM diperkenalkan pada awal 1990-an oleh Vladimir N. Vapnik bersama timnya. Salah satu publikasi penting terkait pengembangan metode ini adalah makalah berjudul “Support Vector Method for Function Approximation, Regression Estimation, and Signal Processing” yang diterbitkan pada tahun 1995 (Boser, Guyon, & Vapnik, 1992).
1.3 Tujuan dan Konsep Dasar
SVM terutama digunakan dalam tugas klasifikasi biner. Algoritma ini bekerja dengan membedakan dua kelas melalui pencarian hyperplane terbaik—yakni bidang keputusan yang memaksimalkan margin antar titik data terdekat dari masing-masing kelas (James et al., 2013).
Bentuk hyperplane bergantung pada jumlah fitur dalam data: jika dua fitur, maka hyperplane adalah garis dalam ruang 2D; jika lebih, maka menjadi bidang dalam ruang berdimensi lebih tinggi. Karena banyak hyperplane mungkin dapat memisahkan kelas, maka prinsip margin maksimum digunakan agar model dapat memilih batas keputusan yang paling optimal dan mampu mengeneralisasi data baru secara akurat.
Titik-titik data yang berada paling dekat dengan hyperplane disebut sebagai support vectors, karena mereka menentukan lokasi dan orientasi margin maksimum tersebut.
Rangkuman istilah dalam SVM
Hyperplane: Batas keputusan dalam ruang fitur.
Support Vectors: Titik data terdekat ke hyperplane.
Margin: Jarak antara hyperplane ke support vector.
Kernel: Fungsi pemetaan ke ruang berdimensi lebih tinggi.
Hard Margin & Soft Margin: Untuk data yang dapat atau tidak dapat dipisahkan secara sempurna.
Parameter C: Regulasi penalti kesalahan.
Hinge Loss: Fungsi kerugian untuk pelanggaran margin.
Visualisasi Margin dan Hyperplane
library(e1071)
library(ggplot2)
data(iris)
iris_sub <- subset(iris, Species != "setosa")
iris_sub$Species <- factor(iris_sub$Species)
svm_model <- svm(Species ~ Sepal.Length + Sepal.Width, data = iris_sub, kernel = "linear", cost = 1, scale = FALSE)
plot(svm_model, iris_sub, Sepal.Length ~ Sepal.Width)
Salah satu keunggulan SVM adalah kemampuannya menangani data yang tidak terpisahkan secara linear. Dalam kasus seperti ini, digunakan teknik transformasi dengan fungsi kernel (kernel function) yang memetakan data ke ruang fitur berdimensi lebih tinggi agar dapat dipisahkan secara linear (James et al., 2013)..
Proses ini dikenal sebagai kernel trick. Beberapa jenis kernel yang umum digunakan meliputi:
Linear Kernel
Polynomial Kernel
Radial Basis Function (RBF) Kernel
Sigmoid Kernel
Pemilihan jenis kernel bergantung pada pola distribusi data dan kebutuhan dari masalah klasifikasi yang sedang dihadapi.
1.4 Jenis Pengklasifikasi SVM
1.4.1 SVM Linier
SVM linier digunakan ketika data dapat dipisahkan secara linier, artinya data dari dua kelas dapat dipisahkan dengan sebuah garis lurus (dalam 2D) atau hyperplane (dalam dimensi lebih tinggi) tanpa perlu transformasi tambahan. Dalam kasus ini, batas keputusan (decision boundary) serta support vectors membentuk struktur yang menyerupai “jalan lurus” (James et al., 2013)..
Profesor Patrick Winston dari MIT menggambarkan analogi SVM linier sebagai upaya “membuat jalan selebar mungkin” yang membentang di antara dua kelas berbeda—sebuah ilustrasi visual dari proses optimasi kuadrat yang dilakukan SVM.
1.4.1.1 Persamaan Hyperplane
Hyperplane dalam SVM linier dinyatakan sebagai:
\[ wx + b = 0 \]
dengan:
\(w\) adalah vektor bobot (weight vector)
\(x\) adalah vektor fitur input
\(b\) adalah bias
1.4.1.2 Margin dan Dua Pendekatan Utama
Untuk menghitung margin, terdapat dua pendekatan utama:
- Hard-Margin SVM
Hard-margin mengasumsikan bahwa semua data dapat dipisahkan tanpa kesalahan. Titik-titik data akan berada di luar margin, tidak ada yang melanggar batas. Dalam pendekatan ini, digunakan formulasi:
\[ (wx_j + b) y_j \geq a \]
dan margin dimaksimalkan melalui:
\[ \max \gamma = \frac{a}{\|w\|} \]
di mana \(a\) adalah margin yang diproyeksikan ke arah vektor \(w\).
- Soft-Margin SVM
Pendekatan soft-margin memungkinkan beberapa titik melanggar margin atau diklasifikasikan secara salah. Untuk itu digunakan variabel slack \(\xi\), dan ditambahkan hyperparameter C yang mengatur keseimbangan antara lebar margin dan kesalahan klasifikasi:
Nilai \(C\) besar: margin menyempit, penalti terhadap kesalahan lebih tinggi
Nilai \(C\) kecil: margin lebih lebar, toleransi terhadap kesalahan lebih besar
Visualisasi SVM Linier
1.4.2 SVM Nonlinier
Dalam banyak kasus di dunia nyata, data tidak dapat dipisahkan secara linier. Untuk menangani situasi ini, digunakan pendekatan Support Vector Machine (SVM) nonlinier. Tujuannya adalah untuk memetakan data ke dalam ruang fitur berdimensi lebih tinggi agar memungkinkan pemisahan secara linier di ruang tersebut (Schölkopf & Smola, 2002).
Namun, meningkatkan dimensi dapat menyebabkan:
Kompleksitas komputasi yang lebih tinggi
Risiko overfitting, terutama jika data terlalu sedikit dibanding jumlah fitur
1.4.3 SVM Nonlinier: Visualisasi Kasus Data Konsentris
Dalam contoh ini, kita menggunakan data berbentuk lingkaran konsentris (tidak linier) dan memisahkannya menggunakan Support Vector Machine (SVM) dengan kernel RBF (Radial Basis Function).
set.seed(123)
data <- mlbench.circle(300, d=2)
df <- data.frame(x1 = data$x[,1], x2 = data$x[,2], y = as.factor(data$classes))model_rbf <- svm(y ~ ., data = df, kernel = "radial", gamma = 1, cost = 1, decision.values = TRUE)Plot Batas Keputusan dan Titik Data
# Buat grid prediksi
grid_vals <- expand.grid(
x1 = seq(min(df$x1) - 0.5, max(df$x1) + 0.5, length.out = 200),
x2 = seq(min(df$x2) - 0.5, max(df$x2) + 0.5, length.out = 200)
)
# Prediksi dan ekstrak margin
grid_vals$y <- predict(model_rbf, grid_vals)
decision_vals <- attributes(predict(model_rbf, grid_vals, decision.values = TRUE))$decision.values
grid_vals$margin <- decision_vals
# Plot
plot_decision <- ggplot() +
geom_contour(data = grid_vals, aes(x = x1, y = x2, z = margin), breaks = 0, colour = "red", size = 1) +
geom_point(data = df, aes(x = x1, y = x2, color = y), size = 2.5) +
labs(title = "SVM Nonlinier dengan Kernel RBF",
x = "Fitur 1", y = "Fitur 2") +
theme_bw() +
scale_color_manual(values = c("#E41A1C", "#377EB8"))
plot_decision
Visualisasi ini menunjukkan bagaimana SVM dengan kernel RBF dapat menangani pola data nonlinier secara efektif, menghasilkan batas keputusan melengkung yang memisahkan dua kelas secara akurat.
1.5 SVM vs Pengklasifikasi Lainnya
Berbagai algoritma pembelajaran terawasi dapat digunakan untuk menyelesaikan masalah klasifikasi yang serupa. Untuk menentukan model terbaik, penting untuk melakukan pengujian dan evaluasi menyeluruh. Namun demikian, memahami keunggulan dan keterbatasan masing-masing model dapat membantu dalam pemilihan algoritma yang paling sesuai.
1.5.1 SVM vs Naive Bayes
Keduanya sering digunakan dalam klasifikasi teks.
SVM unggul ketika data tidak dapat dipisahkan secara linier.
Naive Bayes lebih sederhana dan ringan secara komputasi.
SVM memerlukan penyetelan hyperparameter dan pelatihan yang lebih mahal secara waktu dan sumber daya.
1.5.2 SVM vs Regresi Logistik
SVM lebih cocok untuk data berdimensi tinggi dan tidak terstruktur, seperti teks atau gambar.
SVM lebih tahan terhadap overfitting dan memiliki batas keputusan yang fleksibel.
Regresi logistik lebih ringan dan lebih cepat dalam implementasi, namun rentan terhadap overfitting bila data kompleks.
1.5.3 SVM vs Decision Tree
SVM bekerja lebih baik pada data berdimensi tinggi dan cenderung tidak mudah overfit.
Decision tree lebih cepat dilatih dan lebih mudah diinterpretasikan secara visual.
Untuk dataset kecil dan sederhana, decision tree dapat lebih efisien.
1.5.4 SVM vs Neural Networks
SVM memiliki kontrol regularisasi yang kuat dan umumnya lebih tahan terhadap overfitting.
Neural networks lebih fleksibel dan dapat menangani berbagai macam bentuk input dengan skala besar.
Namun, neural networks memerlukan lebih banyak data dan sumber daya pelatihan.
Catatan: Tidak ada satu model yang terbaik untuk semua situasi. Pemilihan model sebaiknya disesuaikan dengan karakteristik data, tujuan analisis, dan kapasitas komputasi yang tersedia.
1.6 Beragam Aplikasi SVM
Support Vector Machine (SVM) adalah algoritma klasifikasi yang kuat dan fleksibel, sehingga banyak digunakan di berbagai sektor industri dan bidang penelitian. Berikut adalah beberapa penerapan SVM yang paling umum dan berdampak tinggi.
1. Klasifikasi Teks
Banyak digunakan dalam Natural Language Processing (NLP).
Contoh aplikasinya meliputi:
Analisis sentimen (opini positif/negatif)
Deteksi spam pada email
Pemodelan topik dokumen
SVM sangat cocok karena mampu menangani data berdimensi tinggi, seperti representasi kata dalam vektor fitur.
2. Klasifikasi Gambar
Digunakan dalam tugas:
Deteksi objek
Pengambilan gambar berbasis konten (CBIR)
Identifikasi gambar yang dimanipulasi
Dalam bidang keamanan siber, SVM membantu mengklasifikasi citra sebagai otentik atau termodifikasi.
3. Bioinformatika
Diterapkan untuk:
Klasifikasi jenis protein
Analisis ekspresi gen
Diagnosis penyakit berbasis biomarker
Khususnya berguna dalam penelitian kanker, karena mampu mengenali pola halus dalam data biologis kompleks.
4. Sistem Informasi Geografis (GIS)
SVM digunakan untuk:
Menganalisis struktur geofisika lapisan bawah tanah
Mengurangi kebisingan dari sinyal elektromagnetik
Memprediksi likuifaksi tanah akibat gempa, penting dalam teknik sipil dan mitigasi risiko bencana
Kesimpulan: Keunggulan SVM dalam menangani data berdimensi tinggi dan kompleks menjadikannya pilihan ideal untuk berbagai aplikasi klasifikasi modern.
1.7 Kernel Trik
Apa Fungsi Kernel dalam SVM?
Dalam algoritma Support Vector Machine (SVM), fungsi kernel berperan penting dalam menangani masalah klasifikasi nonlinier. Fungsi kernel memungkinkan algoritma SVM bekerja dalam ruang berdimensi lebih tinggi tanpa eksplisit melakukan transformasi data. Ini dikenal sebagai “kernel trick” (Hsu, Chang, & Lin, 2003).
1.7.1 Motivasi Penggunaan Kernel
Seringkali, data tidak dapat dipisahkan secara linier di ruang aslinya. Oleh karena itu, kita ingin memproyeksikan data tersebut ke ruang fitur berdimensi lebih tinggi agar menjadi linier terpisah. Namun, eksplisit menghitung transformasi ke dimensi tinggi bisa sangat mahal secara komputasi.
Fungsi kernel menggantikan dot product eksplisit dari dua vektor yang sudah ditransformasi ke ruang fitur baru dengan perhitungan langsung (Cortes & Vapnik, 1995):
\[ K(x_i, x_j) = \phi(x_i)^T \phi(x_j) \]
di mana:
\(K\): fungsi kernel
\(x_i, x_j\): pasangan data input
\(\phi\): pemetaan ke ruang fitur berdimensi tinggi
Dengan kernel trick, kita tidak perlu tahu bentuk eksplisit dari \(\phi\); cukup tentukan fungsinya saja.
1.7.2 Jenis-Jenis Fungsi Kernel Umum
Berikut adalah beberapa fungsi kernel yang umum digunakan dalam SVM:
- Linear Kernel \[ K(x_i, x_j) = x_i^T x_j \]
- Digunakan ketika data linier terpisah.
- Polynomial Kernel \[ K(x_i, x_j) = (x_i^T x_j + c)^d \]
Mampu menangkap interaksi polinomial antar fitur.
Parameter: derajat \(d\) dan konstanta \(c\).
- Radial Basis Function (RBF) / Gaussian \[ K(x_i, x_j) = \exp(-\gamma \|x_i - x_j\|^2) \]
Paling populer.
Cocok untuk data dengan pola nonlinier kompleks.
Parameter: \(\gamma\).
- Sigmoid Kernel
\[ K(x_i, x_j) = \tanh(\alpha x_i^T x_j + c) \]
- Mirip fungsi aktivasi dalam jaringan saraf.
Inti dari Kernel Trick
Dengan menggunakan fungsi kernel, kita dapat menyelesaikan masalah klasifikasi yang kompleks tanpa perlu secara eksplisit menghitung fitur baru dalam dimensi tinggi.
Hal ini membuat SVM menjadi algoritma yang sangat fleksibel, efisien secara komputasi, dan kuat dalam menghadapi data nonlinier.
Catatan: Pemilihan kernel yang tepat sangat bergantung pada struktur data dan tujuan analisis.
1.8 Cara Kerja Support Vector Machine (SVM)
Bagian ini membahas langkah-langkah dalam membangun model klasifikasi menggunakan Support Vector Machine (SVM), bagaimana pendekatan ini dibandingkan dengan metode supervised learning lainnya, serta aplikasinya dalam dunia industri.
1. Pembagian Data
Langkah pertama dalam proses pembangunan model SVM adalah membagi data menjadi data pelatihan (training set) dan data pengujian (testing set). Praktik ini serupa dengan pendekatan umum dalam supervised learning.
Sebelum membangun model, disarankan melakukan analisis data eksploratif (EDA). Walaupun tidak wajib secara teknis, EDA dapat membantu mengidentifikasi nilai hilang, outlier, dan memahami distribusi data. Hal ini dapat meningkatkan kualitas pelatihan model dan mengurangi bias.
2. Pelatihan dan Evaluasi Model
Setelah data dibagi dan dibersihkan, model SVM dapat dibangun dengan
mengimpor modul dari pustaka seperti e1071 (untuk R) atau
scikit-learn (untuk Python).
Model dilatih menggunakan data pelatihan.
Prediksi dilakukan pada data pengujian.
Evaluasi performa dapat dilakukan dengan:
Akurasi: proporsi prediksi benar
Precision: ketepatan klasifikasi positif
Recall: sensitivitas terhadap kelas positif
F1-score: harmoni antara precision dan recall
3. Penyetelan Hyperparameter
Untuk meningkatkan kinerja model, hyperparameter dalam SVM dapat disesuaikan. Beberapa parameter penting meliputi:
C: parameter regularisasi
gamma: untuk kernel RBF
jenis kernel: linear, polynomial, RBF, sigmoid
Metode umum untuk menyetel hyperparameter adalah:
- Grid Search: mencoba berbagai kombinasi parameter
- Cross Validation: mengevaluasi performa model secara lebih stabil
Penyetelan ini dapat meningkatkan generalisasi model terhadap data baru dan menghindari overfitting.
Catatan: Pemahaman yang kuat terhadap data, ditambah dengan eksperimen penyetelan parameter yang sistematis, dapat membuat model SVM menjadi salah satu alat klasifikasi paling andal dalam machine learning.
1.9 Detail Matematika SVM
Dalam SVM:
Hyperplane: Garis atau bidang pemisah antar kelas
Support Vectors: Titik data terdekat dari masing-masing kelas ke hyperplane
Margin: Jarak antara support vector dan hyperplane
Jika data tidak dapat dipisahkan secara linear, SVM dapat menggunakan teknik kernel trick untuk memetakan data ke ruang berdimensi lebih tinggi.
1.10 Formulasi Matematis Support Vector Machine (SVM)
Pertimbangkan kasus klasifikasi biner dengan dua kelas (+1 dan -1), dan dataset pelatihan terdiri dari pasangan \((x_i, y_i)\), dengan \(x_i \in \mathbb{R}^n\) dan \(y_i \in \{-1, 1\}\).
1.10.1 Hyperplane Linear
Tujuan: Menentukan batas keputusan (decision boundary) yang memisahkan dua kelas dalam ruang fitur.
Fungsi pemisah linear dituliskan sebagai:
\[ w^T x + b = 0 \]
dengan:
\(w\): vektor normal ke hyperplane.
\(b\): bias, yaitu jarak hyperplane ke titik asal sepanjang \(w\).
1.10.2 Jarak Titik ke Hyperplane
Tujuan: Mengukur seberapa jauh suatu titik data dari batas keputusan. Digunakan untuk mengatur margin klasifikasi.
\[ d_i = \frac{w^T x_i + b}{\|w\|} \]
1.10.3 Fungsi Klasifikasi SVM Linear
Tujuan: Mengklasifikasikan titik data baru berdasarkan posisi relatifnya terhadap hyperplane.
\[ \hat{y} = \begin{cases} 1 & \text{jika } w^T x + b \geq 0 \ -1 & \text{jika } w^T x + b < 0 \end{cases} \]
1.10.4 Permasalahan Optimasi SVM Keras (Hard Margin)
Tujuan: Menemukan hyperplane yang memisahkan dua kelas secara sempurna dan memaksimalkan margin.
\[ \min_{w, b} \quad \frac{1}{2} \|w\|^2 \ \text{dengan syarat: } y_i(w^T x_i + b) \geq 1, \quad \forall i = 1, ..., m \]
1.10.4.1 Derivasi Matematis Optimasi SVM Hard-Margin
Tujuan Optimasi
Kita ingin mencari parameter \(\mathbf{w}\) dan \(b\) sehingga:
\[ \min_{\mathbf{w}, b} \quad \frac{1}{2} \|\mathbf{w}\|^2 \quad \text{dengan syarat} \quad y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1, \quad \forall i \]
Masalah Optimasi SVM Hard-Margin
Tujuan: \[ \text{Minimalkan:} \quad \frac{1}{2} \mathbf{w}^T \mathbf{w} \]
Kendala (Constraint): \[ y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1, \quad i = 1, 2, \dots, n \]
Langkah Matematis: Gunakan Lagrangian
Kita definisikan fungsi Lagrangian:
\[ \mathcal{L}(\mathbf{w}, b, \boldsymbol{\alpha}) = \frac{1}{2} \|\mathbf{w}\|^2 - \sum_{i=1}^{n} \alpha_i [ y_i (\mathbf{w}^T \mathbf{x}_i + b) - 1 ] \]
dengan \(\alpha_i \geq 0\) adalah Lagrange multipliers.
Langkah 1: Turunan terhadap \(\mathbf{w}\) dan \(b\)
Ambil turunan pertama dari Lagrangian:
Turunan terhadap \(\mathbf{w}\): \[ \frac{\partial \mathcal{L}}{\partial \mathbf{w}} = \mathbf{w} - \sum_{i=1}^{n} \alpha_i y_i \mathbf{x}_i = 0 \Rightarrow \mathbf{w} = \sum_{i=1}^{n} \alpha_i y_i \mathbf{x}_i \]
Turunan terhadap \(b\): \[ \frac{\partial \mathcal{L}}{\partial b} = -\sum_{i=1}^{n} \alpha_i y_i = 0 \Rightarrow \sum_{i=1}^{n} \alpha_i y_i = 0 \]
Substitusi ke Dual Form
Substitusi ekspresi \(\mathbf{w}\) ke dalam Lagrangian menghasilkan dual problem:
\[ \max_{\boldsymbol{\alpha}} \sum_{i=1}^{n} \alpha_i - \frac{1}{2} \sum_{i=1}^{n} \sum_{j=1}^{n} \alpha_i \alpha_j y_i y_j \mathbf{x}_i^T \mathbf{x}_j \]
Dengan syarat:
\[ \alpha_i \geq 0, \quad \sum_{i=1}^{n} \alpha_i y_i = 0 \]
1.10.4.2 Solusi Akhir
- Temukan \(\alpha^*\) yang memaksimalkan dual problem (bisa menggunakan Quadratic Programming)
- Hitung: \[ \mathbf{w}^* = \sum_{i=1}^{n} \alpha_i^* y_i \mathbf{x}_i \]
- Hitung: \[ b^* = y_k - \mathbf{w}^{*T} \mathbf{x}_k \quad \text{untuk salah satu support vector } \alpha_k > 0 \]
1.10.4.3 Kesimpulan
Untuk meminimalkan \(\frac{1}{2} \|\mathbf{w}\|^2\) dalam SVM:
- Formulasikan Lagrangian
- Ambil turunan terhadap \(\mathbf{w}\) dan \(b\)
- Substitusi ke fungsi dual
- Selesaikan dengan metode Quadratic Programming (QP)
- Dapatkan \(\mathbf{w}^*\) dan \(b^*\)
Ini adalah pendekatan matematis klasik dalam menyelesaikan hard-margin SVM.
1.10.5 Soft Margin dengan Variabel Slack \(\xi_i\)
Tujuan: Mengakomodasi data yang tidak dapat dipisahkan secara sempurna dengan mengizinkan pelanggaran margin melalui variabel kelonggaran \(\xi_i\).
\[ \min_{w, b} \quad \frac{1}{2} \|w\|^2 + C \sum_{i=1}^{m} \xi_i \ \text{dengan syarat: } y_i(w^T x_i + b) \geq 1 - \xi_i, \quad \xi_i \geq 0 \]
dengan:
\(C\): parameter regulasi
\(\xi_i\): slack variable, mengizinkan kesalahan klasifikasi
1.10.6 Dual Problem
Tujuan: Mengubah masalah primal ke bentuk dual agar dapat menggunakan fungsi kernel dan efisien dalam komputasi, terutama pada data berdimensi tinggi.
\[ \max_{\alpha} \sum_{i=1}^{m} \alpha_i - \frac{1}{2} \sum_{i=1}^{m} \sum_{j=1}^{m} \alpha_i \alpha_j y_i y_j K(x_i, x_j) \ \text{dengan syarat: } \sum \alpha_i y_i = 0, \quad 0 \leq \alpha_i \leq C \]
1.10.7 Fungsi Keputusan
Tujuan: Mengklasifikasikan titik uji menggunakan hasil optimisasi dual dan kernel.
\[ f(x) = \sum_{i=1}^{m} \alpha_i y_i K(x_i, x) + b \]
Support vector adalah titik di mana \(\alpha_i > 0\).
Penjelasan ini memberikan gambaran bagaimana SVM menentukan batas keputusan berdasarkan margin maksimum, serta bagaimana pengaruh parameter \(C\), slack, dan kernel terhadap fleksibilitas dan generalisasi model.
2 Contoh perhitungan manual SVM
2.1 Step 0: Format Data
Data:
| \(x_1\) | \(x_2\) | \(y\) |
|---|---|---|
| 2 | 2 | 1 |
| 4 | 4 | 1 |
| 4 | 0 | -1 |
| 0 | 0 | -1 |
Targetnya adalah mencari \(\mathbf{w} = [w_1, w_2]^T\) dan \(b\), sehingga memenuhi kondisi margin:
\[ y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1 \]
library(tibble)
data <- tribble(
~x1, ~x2, ~y,
2 , 2 , 1,
4 , 4 , 1,
4 , 0 , -1,
0 , 0 , -1
)
data## # A tibble: 4 × 3
## x1 x2 y
## <dbl> <dbl> <dbl>
## 1 2 2 1
## 2 4 4 1
## 3 4 0 -1
## 4 0 0 -12.2 Step 1: Plotkan Data untuk Memahami Klasifikasi
Titik dengan label +1: (2,2), (4,4)
Titik dengan label -1: (4,0), (0,0)
Secara visual, mereka dapat dipisahkan oleh garis:
\[ x_2 = x_1 - 1 \]
atau bentuk eksplisit hyperplane: \[ \mathbf{w}^T \mathbf{x} + b = 0 \Rightarrow -x_1 + x_2 + 1 = 0 \]
Dengan kata lain: \[ \mathbf{w} = [-1, 1]^T, \quad b = 1 \]
library(ggplot2)
X <- data.frame(
x1 = c(2, 4, 4, 0),
x2 = c(2, 4, 0, 0),
y = factor(c(1, 1, -1, -1))
)
# Vektor w dan b dari hasil manual
w <- c(-1, 1)
b <- 1
# Hyperplane dan margin
x_vals <- seq(-1, 6, length.out = 100)
y_hyperplane <- x_vals + b # karena -x1 + x2 + b = 0 -> x2 = x1 - b
margin <- sqrt(2)/2
# Garis hyperplane dan margin
df_hyper <- data.frame(x = x_vals, y = x_vals - 1)
df_margin1 <- data.frame(x = x_vals, y = x_vals - 1 + margin)
df_margin2 <- data.frame(x = x_vals, y = x_vals - 1 - margin)
# Visualisasi
ggplot(X, aes(x = x1, y = x2, color = y)) +
geom_point(size = 3) +
geom_line(data = df_hyper, aes(x = x, y = y), color = "black") +
geom_line(data = df_margin1, aes(x = x, y = y), color = "black", linetype = "dashed") +
geom_line(data = df_margin2, aes(x = x, y = y), color = "black", linetype = "dashed") +
labs(title = "Visualisasi Hyperplane Manual SVM", x = "x1", y = "x2") +
xlim(-1, 6) + ylim(-1, 6) +
theme_bw() +
scale_color_manual(values = c("blue", "red"))
2.4 Step 3: Evaluasi Optimalitas
SVM bertujuan meminimalkan:
\[ \min_{\mathbf{w}, b} \frac{1}{2} \|\mathbf{w}\|^2 \quad \text{dengan syarat } y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1 \]
Kita hitung normanya:
\[ \|\mathbf{w}\|^2 = (-1)^2 + 1^2 = 2 \]
Bandingkan dengan contoh alternatif \(\mathbf{w} = [-0.5, 0.5], b = 0.5\):
w_alt <- c(-0.5, 0.5)
b_alt <- 0.5
gamma_alt <- data$y * (data$x1 * w_alt[1] + data$x2 * w_alt[2] + b_alt)
data.frame(x1 = data$x1, x2 = data$x2, y = data$y, gamma_alt)## x1 x2 y gamma_alt
## 1 2 2 1 0.5
## 2 4 4 1 0.5
## 3 4 0 -1 1.5
## 4 0 0 -1 -0.5Salah satu hasil margin < 1, sehingga solusi alternatif tidak feasible.
\(\mathbf{w} = [-1, 1], b = 1\) adalah bukan solusi optimal.
\(\mathbf{w} = [-0.5,0.5 ],b = 1\) adalah bukan solusi optimal.
2.5 Step 4: Garis Margin
Margin SVM adalah:
\[ \text{Margin} = \frac{2}{\|\mathbf{w}\|} = \frac{2}{\sqrt{2}} = \sqrt{2} \]
Garis-garis support vector:
Positif margin:
\[ \mathbf{w}^T \mathbf{x} + b = 1 \Rightarrow x_2 = x_1 \]Negatif margin:
\[ \mathbf{w}^T \mathbf{x} + b = -1 \Rightarrow x_2 = x_1 - 2 \]
2.6 Solusi Optimal dan Feasible untuk SVM Hard-Margin
2.7 Step 0: Format Data
Data yang digunakan:
data <- tribble(
~x1, ~x2, ~y,
2 , 2 , 1,
4 , 4 , 1,
4 , 0 , -1,
0 , 0 , -1
)
data## # A tibble: 4 × 3
## x1 x2 y
## <dbl> <dbl> <dbl>
## 1 2 2 1
## 2 4 4 1
## 3 4 0 -1
## 4 0 0 -12.8 Step 1: Verifikasi Solusi Optimal dan Feasible
Berdasarkan eksplorasi grid search, salah satu kombinasi feasible (semua margin ≥ 1) dengan norma minimum adalah:
\[ \mathbf{w} = [0, 1], \quad b = -1 \]
Kita verifikasi margin:
\[ \gamma_i = y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1 \]
w <- c(0, 1)
b <- -1
data$wx_b <- data$x1 * w[1] + data$x2 * w[2] + b
data$margin_check <- data$y * data$wx_b
data## # A tibble: 4 × 5
## x1 x2 y wx_b margin_check
## <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 2 2 1 1 1
## 2 4 4 1 3 3
## 3 4 0 -1 -1 1
## 4 0 0 -1 -1 1Semua nilai di kolom margin_check bernilai \(\geq 1\), jadi solusi ini valid dan
feasible.
2.9 Step 2: Hitung Norma dan Margin
w_norm_sq <- sum(w^2)
margin <- 2 / sqrt(w_norm_sq)
cat("||w||^2 =", w_norm_sq, "\n")## ||w||^2 = 1cat("Margin =", margin, "\n")## Margin = 22.10 Step 3: Visualisasi Hyperplane dan Margin
Hyperplane: \[ \mathbf{w}^T \mathbf{x} + b = 0 \Rightarrow x_2 = 1 \]
Margin atas: \[ \mathbf{w}^T \mathbf{x} + b = 1 \Rightarrow x_2 = 2 \]
Margin bawah: \[ \mathbf{w}^T \mathbf{x} + b = -1 \Rightarrow x_2 = 0 \]
ggplot(data, aes(x = x1, y = x2, color = factor(y))) +
geom_point(size = 4) +
geom_hline(yintercept = 1, color = "blue", size = 1) +
geom_hline(yintercept = 2, linetype = "dashed", color = "green") +
geom_hline(yintercept = 0, linetype = "dashed", color = "red") +
labs(title = "Visualisasi Hyperplane dan Margin",
x = expression(x[1]), y = expression(x[2]), color = "Label y") +
theme_bw()
Kesimpulan
Solusi optimal dan feasible untuk SVM hard-margin:
- \(\mathbf{w} = [0, 1]\)
- \(b = -1\)
- Semua margin \(\geq 1\)
- Norma \(\|\mathbf{w}\|^2 = 1\)
Ini adalah solusi valid untuk memisahkan data dengan margin maksimum sesuai syarat SVM hard-margin.
📌 Penjelasan ini memberikan gambaran bagaimana SVM menentukan batas keputusan berdasarkan margin maksimum, serta bagaimana pengaruh parameter \(C\), slack, dan kernel terhadap fleksibilitas dan generalisasi model.
2.11 Verifikasi Solusi
Optimal SVM dengan Fungsi svm di R”
2.12 Step 0: Format Data
data <- tribble(
~x1, ~x2, ~y,
2 , 2 , 1,
4 , 4 , 1,
4 , 0 , -1,
0 , 0 , -1
)
data$y <- as.factor(data$y) # convert to factor for svm classification2.13 Step 1: Latih Model SVM dengan Kernel Linear dan C Besar (Hard-Margin)
model <- svm(y ~ x1 + x2, data = data, kernel = "linear", cost = 1e10, scale = FALSE)
model##
## Call:
## svm(formula = y ~ x1 + x2, data = data, kernel = "linear", cost = 1e+10,
## scale = FALSE)
##
##
## Parameters:
## SVM-Type: C-classification
## SVM-Kernel: linear
## cost: 1e+10
##
## Number of Support Vectors: 32.14 Step 2: Ekstrak Koefisien dan Intersep (w dan b)
w <- t(model$coefs) %*% model$SV
b <- -model$rho
w <- as.numeric(w)
cat("w =", w, "\n")## w = 0 0.9995117cat("b =", b, "\n")## b = -0.99967452.15 Step 3: Hitung Margin Check untuk Semua Titik
\[ \gamma_i = y_i (\mathbf{w}^T \mathbf{x}_i + b) \]
data_numeric <- data
levels(data_numeric$y) <- c(-1, 1)
data_numeric$y <- as.numeric(as.character(data_numeric$y))
data_numeric$wx_b <- data_numeric$x1 * w[1] + data_numeric$x2 * w[2] + b
data_numeric$margin_check <- data_numeric$y * data_numeric$wx_b
data_numeric## # A tibble: 4 × 5
## x1 x2 y wx_b margin_check
## <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 2 2 1 0.999 0.999
## 2 4 4 1 3.00 3.00
## 3 4 0 -1 -1.00 1.00
## 4 0 0 -1 -1.00 1.002.16 Step 4: Visualisasi Hyperplane dan Margin
- Hyperplane: \(\mathbf{w}^T \mathbf{x} + b = 0\)
- Margin atas: \(+1\)
- Margin bawah: \(-1\)
ggplot(data, aes(x = x1, y = x2, color = y)) +
geom_point(size = 4) +
geom_abline(
slope = -w[1]/w[2], intercept = -b/w[2], color = "blue", size = 1
) +
geom_abline(
slope = -w[1]/w[2], intercept = (1 - b)/w[2], linetype = "dashed", color = "green"
) +
geom_abline(
slope = -w[1]/w[2], intercept = (-1 - b)/w[2], linetype = "dashed", color = "red"
) +
labs(title = "Hyperplane dan Margin dari Model SVM",
x = expression(x[1]), y = expression(x[2]), color = "y") +
theme_bw()
Kesimpulan
Model SVM menemukan \(\mathbf{w} = [0, 1], b = -1\)
Semua \(\gamma_i \geq 1\) → valid untuk hard-margin SVM
Visualisasi mendukung bahwa margin benar dan semua data dipisahkan dengan benar
Solusi ini adalah solusi feasible dan optimal untuk hard-margin SVM.
Kesimpulan
Langkah-langkah mencari \(\mathbf{w}_{\text{optimal}}\) dalam SVM:
Tentukan data dan label \(y \in \{-1, 1\}\)
Tentukan bentuk hyperplane \(\mathbf{w}^T \mathbf{x} + b = 0\)
Pastikan semua data memenuhi syarat margin \(y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1\)
Hitung \(\|\mathbf{w}\|^2\) dan cari \(\mathbf{w}\) dengan norma terkecil
Verifikasi bahwa support vectors memenuhi margin = 1
Selesai: \(\mathbf{w} = [0, 1], b = 1\) adalah solusi optimal
2.17 Implementasi SVM linear dengan R
2.17.1 Contoh 1: SVM Linear untuk Dua Kelas
# Data dua kelas, separable secara linear
data_lin2 <- data.frame(
x1 = c(rnorm(150, mean = 1), rnorm(150, mean = 4)),
x2 = c(rnorm(150, mean = 1), rnorm(150, mean = 4)),
y = factor(c(rep("A", 150), rep("B", 150)))
)
svm_lin2 <- svm(y ~ ., data = data_lin2, kernel = "linear", cost = 1)plot(svm_lin2, data_lin2, x1 ~ x2,
main = "SVM Linear untuk Dua Kelas")
2.17.2 Contoh 2: SVM Linear untuk Tiga Kelas
# Simulasi data 3 kelas secara linear
n <- 150
class1 <- data.frame(
x1 = rnorm(n, 1),
x2 = rnorm(n, 1),
y = factor("A")
)
class2 <- data.frame(
x1 = rnorm(n, 3),
x2 = rnorm(n, 4),
y = factor("B")
)
class3 <- data.frame(
x1 = rnorm(n, 5),
x2 = rnorm(n, 1),
y = factor("C")
)
multi_lin_data <- bind_rows(class1, class2, class3)svm_multi_linear <- svm(y ~ ., data = multi_lin_data, kernel = "linear", cost = 1)plot(svm_multi_linear, multi_lin_data, x1 ~ x2,
main = "SVM Linear untuk Tiga Kelas")
Kesimpulan
SVM linear bekerja baik jika data dapat dipisahkan secara linear.
Untuk lebih dari dua kelas, SVM menggunakan strategi one-vs-one.
Kernel memungkinkan SVM membangun boundary kompleks di ruang transformasi tanpa eksplisit melakukan transformasi itu sendiri.
2.18 SVM Non Linier
2.18.1 Penggunaan Kernel dalam SVM
2.18.2 Simulasi Data Non-Linear Separable
# Data: dua lingkaran (non-linear separable)
n <- 100
r1 <- 1; r2 <- 2
theta1 <- runif(n, 0, 2*pi)
theta2 <- runif(n, 0, 2*pi)
x_inner <- data.frame(
x1 = r1 * cos(theta1) + rnorm(n, 0, 0.1),
x2 = r1 * sin(theta1) + rnorm(n, 0, 0.1),
y = factor(1)
)
x_outer <- data.frame(
x1 = r2 * cos(theta2) + rnorm(n, 0, 0.1),
x2 = r2 * sin(theta2) + rnorm(n, 0, 0.1),
y = factor(-1)
)
data <- rbind(x_inner, x_outer)2.18.3 Visualisasi Data
ggplot(data, aes(x = x2, y = x1, color = y)) +
geom_point(size = 2) +
labs(title = "Data Non-Linear Separable (2 Lingkaran)",
color = "Kelas") +
theme_bw()
2.18.4 Model SVM dengan Kernel Linear (Gagal Memisahkan)
svm_linear <- svm(y ~ ., data = data, kernel = "linear", cost = 1)plot(svm_linear, data, x1 ~ x2,
main = "SVM dengan Kernel Linear (Gagal Memisahkan)")
2.18.5 Model SVM dengan Kernel RBF (Berhasil Memisahkan)
svm_rbf <- svm(y ~ ., data = data, kernel = "radial", cost = 1, gamma = 1)plot(svm_rbf, data, x1 ~ x2,
main = "SVM dengan Kernel RBF (Berhasil Memisahkan)")
Kesimpulan
Kernel linear gagal menangani data non-linear separable.
Kernel RBF (Gaussian) mampu membuat boundary non-linear yang memisahkan dua kelas dengan baik.
Kernel trick memungkinkan kita memetakan data ke ruang fitur tinggi secara implisit, sehingga klasifikasi non-linear bisa dilakukan tanpa transformasi eksplisit.
2.19 SVM Non Linear untuk tiga kelas
2.19.1 Simulasi Data Non-Linear Separable (2 Kelas)
# Data: dua lingkaran (non-linear separable)
n <- 100
r1 <- 1; r2 <- 2
theta1 <- runif(n, 0, 2*pi)
theta2 <- runif(n, 0, 2*pi)
x_inner <- data.frame(
x1 = r1 * cos(theta1) + rnorm(n, 0, 0.1),
x2 = r1 * sin(theta1) + rnorm(n, 0, 0.1),
y = factor("A")
)
x_outer <- data.frame(
x1 = r2 * cos(theta2) + rnorm(n, 0, 0.1),
x2 = r2 * sin(theta2) + rnorm(n, 0, 0.1),
y = factor("B")
)
# Tambahkan kelas ketiga secara acak di area atas
x_third <- data.frame(
x1 = runif(n, -3, 3),
x2 = runif(n, 2.5, 4),
y = factor("C")
)
data_multi <- bind_rows(x_inner, x_outer, x_third)2.19.2 Visualisasi Data 3 Kelas
ggplot(data_multi, aes(x = x2, y = x1, color = y)) +
geom_point(size = 2) +
labs(title = "Data 3 Kelas untuk SVM Multiclass",
color = "Kelas") +
theme_bw()
2.19.3 Model SVM Multiclass dengan Kernel RBF
svm_multi <- svm(y ~ ., data = data_multi, kernel = "radial", cost = 1, gamma = 1)plot(svm_multi, data_multi, x1 ~ x2,
main = "SVM Multiclass dengan Kernel RBF")
Kesimpulan
SVM mendukung klasifikasi untuk lebih dari dua kelas dengan pendekatan one-vs-one secara otomatis.
Kernel RBF mampu memisahkan kelas non-linear dalam kasus multiclass seperti contoh ini.
Untuk kasus dengan lebih dari dua kelas,
e1071::svm()menangani klasifikasi dengan membangun beberapa hyperplane antar pasangan kelas.
3 Support Vector Regression (SVR)
Support Vector Regression (SVR) merupakan salah satu metode dalam pembelajaran mesin yang berguna untuk melakukan prediksi nilai kontinu. Berbeda dengan regresi biasa yang berusaha meminimalkan keseluruhan kesalahan prediksi, SVR memiliki pendekatan yang unik melalui konsep ε-tube atau epsilon-tube.
3.1 Apa itu Tube dalam SVR?
“Tube” dalam SVR adalah istilah yang menggambarkan margin toleransi kesalahan di sekitar fungsi prediksi. Secara teknis disebut sebagai ε-tube.
3.2 Tujuan Utama
Dalam SVR, kita tidak berusaha meminimalkan semua kesalahan, melainkan mencari fungsi regresi \(f(x) = w \cdot x + b\) yang:
- Memberikan kesalahan kurang dari atau sama dengan ε (epsilon) untuk sebanyak mungkin data.
- Tidak mempermasalahkan kesalahan kecil dalam rentang ±ε.
3.3 Visualisasi Konseptual
Bayangkan sebuah terowongan (tube) di sekitar garis regresi:
- Lebar tube adalah \(2\epsilon\) (dari \(+\epsilon\) ke \(-\epsilon\)).
- Titik data yang berada dalam tube dianggap cukup baik → tidak dikenai penalti.
- Titik data yang berada di luar tube → dikenai penalti, biasanya dengan fungsi loss epsilon-insensitive.
3.4 Tujuan Penggunaan Tube
Support Vector Regression (SVR) adalah varian dari Support Vector Machine (SVM) yang digunakan untuk masalah regresi. Salah satu komponen penting dari SVR adalah konsep epsilon-tube (ε-tube), yang berfungsi untuk menciptakan model yang lebih robust terhadap noise dan menghindari overfitting.
3.4.1 Menghindari Overfitting
Dalam regresi tradisional seperti regresi linear, model bertujuan untuk meminimalkan semua kesalahan sekecil mungkin. Ini berisiko membuat model terlalu fleksibel, sehingga menangkap noise atau outlier sebagai bagian dari pola.
SVR memperkenalkan epsilon-tube yang memungkinkan model “santai” terhadap kesalahan kecil. Kesalahan prediksi yang masih dalam batas ±ε tidak dikenakan penalti.
Contoh:
Jika target sebenarnya adalah 10 dan prediksi adalah 10.3, maka selisih
0.3 tidak dipermasalahkan jika ε = 0.5. Model tidak akan diubah secara
signifikan untuk menyesuaikan titik tersebut.
Hasil:
Model menjadi lebih general dan tidak terlalu mengikuti fluktuasi kecil
dari data.
3.4.2 Menoleransi Noise Kecil
Dalam data dunia nyata, noise tidak dapat dihindari. Noise adalah variasi acak yang tidak mewakili pola sebenarnya.
SVR menyatakan secara eksplisit:
“Selama kesalahan prediksi berada dalam ±ε, saya anggap itu masih dapat diterima.”
Dengan cara ini, model tidak mudah terpengaruh oleh kesalahan kecil yang bisa disebabkan oleh gangguan acak atau ketidaksempurnaan pengukuran.
Contoh:
Dalam pengukuran suhu, perbedaan ±0.2°C mungkin terjadi karena kesalahan
sensor dan bukan pola yang berarti. SVR mengabaikan selisih ini agar
model tetap fokus pada tren utama.
3.4.3 Fokus pada Titik-Titik Data yang Melampaui Batas Toleransi (Support Vectors)
Titik data yang berada di luar epsilon-tube memiliki kesalahan lebih besar dari ε. Titik-titik inilah yang digunakan untuk membentuk model SVR.
Titik-titik ini disebut support vectors karena mereka menentukan parameter model akhir (w dan b).
Sebaliknya, data yang berada dalam tube tidak memengaruhi pembentukan model.
Konsekuensi:
Model menjadi lebih sederhana dan efisien.
Fokus hanya pada data penting.
Ibaratnya: “Mengabaikan gangguan kecil, fokus pada yang penting.”
Kesimpulan
Konsep epsilon-tube dalam SVR memberikan banyak keuntungan, antara lain:
Mencegah model dari overfitting.
Menoleransi noise kecil dalam data.
Memfokuskan pembelajaran hanya pada data yang penting.
Dengan demikian, SVR sangat berguna dalam situasi di mana data tidak sempurna namun kita tetap ingin membuat model yang kuat dan general. Konsep ε-tube dalam SVR memberikan keseimbangan antara fleksibilitas dan ketegasan. Model dapat mentoleransi kesalahan kecil tanpa terlalu dipengaruhi oleh noise, sekaligus mempertahankan fokus pada data penting yang melampaui margin toleransi.
Dengan pendekatan ini, SVR menjadi sangat berguna dalam banyak kasus regresi nyata yang mengandung noise atau variasi kecil yang tidak signifikan.
Visualisasi
library(ggplot2)
library(gridExtra)
set.seed(123)
# Data
x <- seq(0, 10, length.out = 20)
y <- 0.8 * x + rnorm(20, 0, 1)
df <- data.frame(x = x, y = y)
model_ols <- lm(y ~ x, data = df)
df$y_pred <- predict(model_ols)
# Garis SVR (dianggap sebagai garis tengah tube)
model_svr <- lm(y ~ x, data = df) # untuk keperluan visual kita gunakan regresi linier saja
df$y_svr <- predict(model_svr)
epsilon <- 1
# Buat data untuk tube
tube_df <- data.frame(
x = df$x,
y_min = df$y_svr - epsilon,
y_max = df$y_svr + epsilon
)Ordinary Least Squares (OLS)
p1 <- ggplot(df, aes(x, y)) +
geom_point() +
geom_abline(intercept = coef(model_ols)[1], slope = coef(model_ols)[2], linetype = "dotted") +
geom_segment(aes(xend = x, yend = y_pred), color = "darkgreen", linetype = "dashed") +
labs(title = "Ordinary Least Squares", y = "X2", x = "X1") +
theme_bw() SVR dengan ε-Tube
p2 <- ggplot(df, aes(x, y)) +
geom_point() +
geom_ribbon(data = tube_df, aes(x = x, ymin = y_min, ymax = y_max), fill = "yellow", alpha = 0.4) +
geom_line(aes(x = x, y = y_svr), linetype = "dotted") +
geom_hline(yintercept = df$y_svr[1] + epsilon, linetype = "dashed", color = "gray") +
geom_hline(yintercept = df$y_svr[1] - epsilon, linetype = "dashed", color = "gray") +
labs(title = expression(paste(epsilon, "-Insensitive Tube")), y = "X2", x = "X1") +
theme_bw() Gabungan Visualisasi
grid.arrange(p1, p2, ncol = 2)
Penjelasan:
Panel kiri menunjukkan OLS yang meminimalkan error kuadrat.
Panel kanan menunjukkan SVR dengan margin ε, di mana hanya titik di luar tube yang dianggap dalam perhitungan.
3.4.4 Posisi Data Terhadap Epsilon-Tube
Dalam Support Vector Regression (SVR), posisi titik data terhadap ε-tube menentukan apakah titik tersebut berkontribusi terhadap pembentukan model atau tidak. Terdapat tiga jenis posisi:
Di Dalam Tube (|yᵢ - f(xᵢ)| < ε)
Tidak dihitung dalam loss function
Tidak memengaruhi model
Bukan support vector
Tepat di Tepi Tube (|yᵢ - f(xᵢ)| = ε)
Termasuk support vector
Titik kritis yang menyentuh batas toleransi
Di Luar Tube (|yᵢ - f(xᵢ)| > ε)
Kesalahan dihitung dan dikenai penalti
Termasuk support vector
3.5 Makna Support Vectors dalam SVR
Support vectors pada SVR adalah titik-titik data yang:
Menentukan bentuk tube: baik menyentuh batas ±ε atau melebihi batas tersebut
Muncul dalam solusi dual sebagai titik dengan nilai α ≠ 0
Membentuk hyperplane regresi secara eksplisit
Kenapa “Titik di Dalam Tube: Diabaikan” Tujuan SVR bukanlah meminimalkan semua kesalahan secara absolut, melainkan membangun model yang cukup baik dalam rentang toleransi \(\epsilon\). Jika kesalahan prediksi masih dalam batas ±\(\epsilon\), maka dianggap bahwa model sudah cukup baik dan tidak perlu diubah.
Dalam konteks SVR dengan ε-insensitive loss, sebuah titik data dikatakan di dalam tube jika:
\[ |y_i - f(x_i)| \leq \epsilon \]
Artinya, prediksi model cukup dekat dengan nilai sebenarnya, sehingga tidak dikenai penalti.
Maksud “Diabaikan”
Tidak berkontribusi dalam proses optimasi model.
Tidak memengaruhi perhitungan parameter \(w\) dan \(b\).
Dalam perhitungan dual form SVR:
\[ \alpha_i = 0 \quad \text{dan} \quad \alpha_i^* = 0 \]
Artinya: bukan support vector.
Contoh
Misalkan model SVR:
\[ f(x) = x + 1 \]
Titik data:
- (2, 3.05) → Prediksi: 3 → Error: 0.05 → Di dalam
tube jika \(\epsilon = 0.1\) →
Diabaikan
- (2, 3.5) → Error: 0.5 → Di luar tube → Dikenai penalti dan memengaruhi model
Titik-titik yang berada di dalam ε-tube dianggap tidak signifikan dalam pembentukan model SVR karena kesalahannya masih dalam batas toleransi. Oleh karena itu, mereka tidak masuk dalam optimasi dan tidak menjadi bagian dari support vectors.
3.6 Model Matematis SVR
Support Vector Regression (SVR) bertujuan menemukan fungsi regresi \(f(x) = w^T x + b\) yang:
Sederhana (norma \(w\) kecil untuk regularisasi)
Tidak menghukum kesalahan kecil (dalam batas \(\epsilon\))
Memberikan penalti terhadap kesalahan besar di luar \(\epsilon\)-tube
3.6.1 Karakteristik Utama dalam Support Vector Regression (SVR)
Support Vector Regression (SVR) memiliki beberapa karakteristik penting yang membedakannya dari regresi linear biasa, khususnya dalam cara model menangani kesalahan dan kompleksitas.
1. Sederhana: Regularisasi dengan Norma \(||w||\) Kecil
SVR berusaha mencari model regresi linear \(f(x) = w \cdot x + b\) yang sederhana, dalam arti nilai vektor bobot \(w\) yang kecil. Tujuannya adalah untuk menghindari model yang terlalu kompleks dan overfitting. Hal ini dicapai melalui regularisasi, yaitu dengan meminimalkan \(||w||^2\) sebagai bagian dari fungsi objektif.
Semakin kecil nilai \(||w||\), semakin “halus” atau tidak tajam garis regresi yang dihasilkan. Ini membantu menjaga generalisasi model pada data baru.
Catatan Regularisasi
Salah satu komponen penting dalam SVR adalah regularisasi, yang digunakan untuk menjaga model tetap sederhana dan menghindari overfitting.
SVR menggunakan regularisasi dengan cara meminimalkan norma dari vektor bobot \(w\), yaitu:
\[ ||w||^2 \quad \text{atau} \quad \frac{1}{2}||w||^2 \]
Tujuan:
Semakin kecil nilai \(||w||\), maka fungsi regresi akan semakin datar atau tidak ekstrem.
Hal ini penting untuk menghindari model terlalu mengikuti fluktuasi kecil pada data pelatihan yang bisa saja hanya disebabkan oleh noise.
Regularisasi adalah kunci dalam membangun model yang tidak hanya akurat terhadap data pelatihan, tetapi juga memiliki kemampuan generalisasi yang baik terhadap data baru.
Perhatikan Fungsi Objektif SVR. SVR memformulasikan masalah optimasi sebagai berikut:
\[ \min_{w,b,\xi,\xi^*} \ \frac{1}{2}||w||^2 + C \sum_{i=1}^{n} (\xi_i + \xi_i^*) \]
Penjelasan Komponen:
\(\frac{1}{2}||w||^2\): Komponen regularisasi. Semakin kecil nilai ini, semakin sederhana modelnya.
\(C\): Parameter yang mengontrol keseimbangan antara kompleksitas model dan jumlah pelanggaran terhadap margin \(\epsilon\).
\(\xi_i\), \(\xi_i^*\): Slack variables, yaitu ukuran pelanggaran data terhadap batas \(\epsilon\) (epsilon-tube). Jika data berada di luar margin, slack variables akan > 0.
Inti dari Regularisasi
Regularisasi di SVR bertujuan untuk:
Menjaga agar model tidak terlalu kompleks.
Menghindari overfitting, terutama pada data dengan noise.
Meningkatkan generalisasi model pada data baru.
Dengan regularisasi, SVR tidak hanya mencari model yang cocok untuk data pelatihan, tetapi juga yang mampu bekerja dengan baik pada data yang belum pernah dilihat sebelumnya.
2. Tidak Menghukum Kesalahan Kecil dalam Batas \(\epsilon\)
Berbeda dari regresi biasa yang meminimalkan selisih kuadrat atau absolut dari prediksi terhadap nilai aktual, SVR memperkenalkan \(\epsilon\)-insensitive loss function. Artinya:
Selama kesalahan prediksi \(\left| y_i - f(x_i) \right| \leq \epsilon\), maka tidak diberikan penalti.
Nilai \(\epsilon\) ini membentuk sebuah margin toleransi (dikenal sebagai \(\epsilon\)-tube) di sekitar garis regresi.
Ini memberikan fleksibilitas terhadap noise kecil dan menghindari penalti berlebihan pada kesalahan yang tidak signifikan.
3. Penalti terhadap Kesalahan Besar di Luar \(\epsilon\)-Tube
Jika sebuah titik data memiliki kesalahan prediksi yang melampaui batas \(\epsilon\), maka:
SVR akan memberikan penalti linier terhadap selisih yang melebihi \(\epsilon\).
Penalti ini dimodelkan melalui variabel slack \(\xi_i\) dan \(\xi_i^*\) yang mencerminkan seberapa jauh titik tersebut berada di luar tube.
Fungsi loss-nya dalam bentuk matematis: \[ L_{\epsilon}(y, f(x)) = \begin{cases} 0, & \text{jika } |y - f(x)| \leq \epsilon \ |y - f(x)| - \epsilon, & \text{jika } |y - f(x)| > \epsilon \end{cases} \]
Penalti ini mendorong model untuk hanya fokus memperbaiki prediksi yang benar-benar buruk, bukan memperbaiki setiap kesalahan kecil.
Penalti dalam SVR digunakan untuk menghukum prediksi yang melampaui batas toleransi kesalahan sebesar \(\epsilon\). Jika sebuah titik data memiliki kesalahan lebih besar dari \(\epsilon\), maka dikenakan penalti dalam bentuk slack variables:
\[ C \sum_{i=1}^{n}(\xi_i + \xi_i^*) \]
Penjelasan:
\(\xi_i\) dan \(\xi_i^*\) menyatakan seberapa besar pelanggaran terhadap margin.
Parameter \(C\) mengontrol seberapa berat hukuman atas kesalahan tersebut.
Semakin besar \(C\), semakin keras model menghukum kesalahan prediksi di luar batas \(\epsilon\).
Fungsi Objektif SVR Lengkap
Gabungan regularisasi dan penalti membentuk fungsi objektif SVR berikut:
\[ \min_{w,b,\xi,\xi^*} \ \frac{1}{2}||w||^2 + C \sum_{i=1}^{n} (\xi_i + \xi_i^*) \]
Perbandingan Regularisasi dan Penalti
| Aspek | Regularisasi | Penalti |
|---|---|---|
| Tujuan | Menyederhanakan model | Mengontrol pelanggaran batas \(\epsilon\) |
| Komponen matematis | \(\frac{1}{2}||w||^2\) | \(C \sum_{i=1}^{n}(\xi_i + \xi_i^*)\) |
| Efek | Menghindari overfitting | Menjaga kesalahan besar tetap terkendali |
Penalti memastikan bahwa model tetap akurat, bahkan jika beberapa titik data sulit diprediksi.
Ilustrasi Penalti
Simulasi \(C\) besar dan kecil - Pengaruh Nilai C dalam SVR
library(e1071)
library(ggplot2)
set.seed(42)Simulasi Data
# Buat data sederhana
x <- seq(0, 10, length.out = 100)
y <- 0.5 * x + 2 + rnorm(100, sd = 0.3)
df <- data.frame(x = x, y = y)SVR dengan Nilai C Kecil
model_smallC <- svm(y ~ x, data = df, type = "eps-regression", cost = 0.1, epsilon = 0.2)
df$pred_smallC <- predict(model_smallC, df)SVR dengan Nilai C Besar
model_largeC <- svm(y ~ x, data = df, type = "eps-regression", cost = 100, epsilon = 0.2)
df$pred_largeC <- predict(model_largeC, df)Visualisasi Hasil Prediksi
ggplot(df, aes(x = x)) +
geom_point(aes(y = y), color = "gray60", alpha = 0.6) +
geom_line(aes(y = pred_smallC), color = "blue", linewidth = 1.2, linetype = "dashed") +
geom_line(aes(y = pred_largeC), color = "red", linewidth = 1.2) +
labs(title = "Pengaruh Nilai C dalam SVR",
subtitle = "Garis Merah: C besar (lebih kaku) | Garis Biru Putus-putus: C kecil (lebih fleksibel)",
y = "y", x = "x") +
theme_bw()
Interpretasi
Model dengan C kecil (biru putus-putus): Lebih fleksibel, mengabaikan kesalahan kecil dan tidak terlalu fokus memperbaiki pelanggaran \(\epsilon\).
Model dengan C besar (merah): Lebih kaku, berusaha keras memperbaiki setiap pelanggaran, sehingga garis regresi lebih menempel pada data.
Maka, mengenakan penalti memang berarti titik yang melanggar margin ε lebih diperhatikan, bukan diabaikan.
3.7 Fungsi Objektif
Diberikan data pelatihan \((\mathbf{x}_i, y_i),\ i = 1, \dots, n\), kita ingin mencari fungsi regresi linear:
\[ f(\mathbf{x}) = \mathbf{w}^T \mathbf{x} + b \]
yang memprediksi \(y_i\) dengan deviasi tidak lebih besar dari \(\varepsilon\) (epsilon-tube), dan meminimalkan kompleksitas model (panjang vektor w).
Objective Function (Soft Margin \(\varepsilon\)-insensitive)
Karena tidak semua data bisa berada dalam \(\varepsilon\)-tube, kita perkenalkan slack variables \(\xi_i, \xi_i^*\) untuk mengakomodasi pelanggaran batas:
\[ \min_{w, b, \xi_i, \xi_i^*} \ \frac{1}{2} \|w\|^2 + C \sum_{i=1}^m (\xi_i + \xi_i^*) \]
Dengan syarat:
\[ \begin{cases} y_i - w^T x_i - b \leq \epsilon + \xi_i \\ w^T x_i + b - y_i \leq \epsilon + \xi_i^* \\ \xi_i, \xi_i^* \geq 0 \end{cases} \]
3.8 Fungsi Lagrangian
Fungsi Lagrangian adalah cara untuk menggabungkan objective function (fungsi tujuan) dengan kendala (constraints) menggunakan Lagrange multipliers. Tujuannya adalah agar kita bisa mengubah problem optimisasi terikat menjadi problem tanpa kendala, yang dapat kita selesaikan dengan teknik turunan biasa Karush-Kuhn-Tucker (KKT) conditions.
Untuk setiap kendala, kita perkenalkan Lagrange multipliers:
| Kendala | Multiplier |
|---|---|
| \(y_i - (\mathbf{w}^T \mathbf{x}_i + b) \leq \varepsilon + \xi_i\) | \(\alpha_i \geq 0\) |
| \((\mathbf{w}^T \mathbf{x}_i + b) - y_i \leq \varepsilon + \xi_i^*\) | \(\alpha_i^* \geq 0\) |
| \(\xi_i \geq 0\) | \(\eta_i \geq 0\) |
| \(\xi_i^* \geq 0\) | \(\eta_i^* \geq 0\) |
Mereka berfungsi sebagai penekan atau penalti terhadap pelanggaran kendala tersebut. Fungsi Lagrangian dibentuk dengan menjumlahkan fungsi objektif utama dan dikurangi setiap kendala yang dikalikan dengan multiplier-nya. Bentuk fungsi Lagrangian dengan Lagrange multipliers \(\alpha_i\), \(\alpha_i^*\), \(\eta_i\), \(\eta_i^*\):
\[ \begin{aligned} L &= \frac{1}{2} \|w\|^2 + C \sum_{i=1}^m (\xi_i + \xi_i^*) \\ &\quad - \sum_{i=1}^m \alpha_i (\epsilon + \xi_i - y_i + w^T x_i + b) \\ &\quad - \sum_{i=1}^m \alpha_i^* (\epsilon + \xi_i^* + y_i - w^T x_i - b) \\ &\quad - \sum_{i=1}^m \eta_i \xi_i - \sum_{i=1}^m \eta_i^* \xi_i^* \end{aligned} \]
Penurunan ini digunakan dalam formulasi primal-dual untuk Support Vector Regression (SVR).
Catatan:
\(\frac{1}{2}\|w\|^2\) → mengontrol kompleksitas model (regularisasi)
\(C \sum (\xi_i + \xi_i^*)\) → menghukum pelanggaran margin \(\epsilon\)
3.9 Variabel Primal dan Dual
3.9.1 Formulasi Primal dan Dual dalam SVR
Support Vector Regression (SVR) bukan hanya soal membentuk fungsi regresi yang meminimalkan kesalahan, tetapi juga bagaimana menyusun formulasi matematis yang memungkinkan solusi optimal secara efisien dan dapat dihitung secara numerik.
Mengapa Diperlukan Formulasi Primal dan Dual?
Dalam SVR, kita dihadapkan pada masalah optimisasi dengan kendala, yaitu:
Minimalkan kompleksitas model (melalui \(||w||^2\)),
Toleransi terhadap kesalahan kecil (ε-insensitive),
Penalti terhadap kesalahan besar (slack variables).
Untuk menyelesaikan masalah tersebut secara sistematis, kita menggunakan formulasi primal dan kemudian mengkonversinya ke dalam formulasi dual, dengan alasan berikut:
1. Formulasi Primal: Titik Awal Secara Konseptual
Formulasi primal adalah bentuk awal dari fungsi objektif SVR, yang melibatkan variabel langsung seperti \(w\), \(b\), dan slack variables (\(\xi\), \(\xi^*\)).
Tujuan utama:
Menyusun fungsi objektif yang mencerminkan trade-off antara kesederhanaan model dan kesalahan prediksi.
Mengatur kendala-kendala yang mencerminkan toleransi \(\epsilon\).
Namun, secara numerik, primal kurang efisien untuk diselesaikan langsung, terutama saat data berdimensi tinggi.
2. Formulasi Dual: Solusi yang Lebih Efisien
Melalui pendekatan Lagrangian, formulasi primal dikonversi ke bentuk dual, dengan mengganti variabel primal (\(w\), \(\xi\)) menjadi variabel dual (\(\alpha_i\), \(\alpha_i^*\)).
Keuntungan formulasi dual:
Hanya bergantung pada produk dalam antar data: \(x_i \cdot x_j\), sehingga mudah diubah menjadi kernel untuk kasus non-linear.
Kompleksitas komputasi dapat ditekan dengan lebih efisien menggunakan metode numerik (misalnya, Quadratic Programming).
Fokus pada support vectors yang relevan saja.
Dengan kata lain, formulasi primal penting untuk pemahaman konseptual, sedangkan formulasi dual penting untuk perhitungan praktis.
Formulasi primal membantu merumuskan masalah SVR secara eksplisit.
Formulasi dual memungkinkan kita menyelesaikan masalah tersebut secara numerik dan memperluas SVR ke data non-linear melalui kernel trick.
Primal dan Dual saling melengkapi, dan penting untuk dipahami dalam membangun model SVR yang kuat dan efisien.
3.9.2 Turunan variabel primal
Agar diperoleh solusi optimal, kita ambil turunan parsial dan setel sama dengan nol: 1. Turunan terhadap \(\mathbf{w}\):
\[ \frac{\partial L}{\partial \mathbf{w}} = \mathbf{w} - \sum_{i=1}^{n} (\alpha_i - \alpha_i^*) \mathbf{x}_i = 0 \Rightarrow \mathbf{w} = \sum_{i=1}^{n} (\alpha_i - \alpha_i^*) \mathbf{x}_i \]
2. Turunan terhadap \(b\):
\[ \frac{\partial L}{\partial b} = \sum_{i=1}^{n} (\alpha_i - \alpha_i^*) = 0 \]
3. Turunan terhadap \(\xi_i\) dan \(\xi_i^*\):
\[ \frac{\partial L}{\partial \xi_i} = C - \alpha_i - \eta_i = 0 \Rightarrow \alpha_i \leq C \]
\[ \frac{\partial L}{\partial \xi_i^*} = C - \alpha_i^* - \eta_i^* = 0 \Rightarrow \alpha_i^* \leq C \]
3.9.3 Dual Formulation
Substitusikan \(\mathbf{w}\) dan \(b\) ke fungsi Lagrangian, kita peroleh bentuk dual sebagai berikut:
\[ \max_{\alpha_i, \alpha_i^*} \quad - \frac{1}{2} \sum_{i=1}^{n} \sum_{j=1}^{n} (\alpha_i - \alpha_i^*)(\alpha_j - \alpha_j^*) \langle \mathbf{x}_i, \mathbf{x}_j \rangle - \varepsilon \sum_{i=1}^{n} (\alpha_i + \alpha_i^*) + \sum_{i=1}^{n} y_i (\alpha_i - \alpha_i^*) \]
Dengan kendala:
\[ \sum_{i=1}^{n} (\alpha_i - \alpha_i^*) = 0 \]
\[ 0 \leq \alpha_i, \alpha_i^* \leq C \]
3.10 Fungsi Prediksi Akhir
Setelah diperoleh solusi \(\alpha_i\) dan \(\alpha_i^*\), maka:
\[ \mathbf{w} = \sum_{i=1}^{n} (\alpha_i - \alpha_i^*) \mathbf{x}_i \]
Dengan menggunakan nilai \(\mathbf{w}\), kita bisa menyusun fungsi prediksi sebagai:
\[ f(\mathbf{x}) = \sum_{i=1}^{n} (\alpha_i - \alpha_i^*) \langle \mathbf{x}_i, \mathbf{x} \rangle + b \]
Penjelasan
\(\mathbf{w}\) adalah vektor bobot yang menunjukkan kontribusi dari masing-masing data training terhadap model. Dalam SVR, bobot ini tidak ditentukan langsung dari data, tapi dari hasil optimisasi dual melalui \(\alpha_i\) dan \(\alpha_i^*\).
\(\langle \mathbf{x}_i, \mathbf{x} \rangle\) adalah inner product atau dot product antara vektor input training \(\mathbf{x}_i\) dan vektor input baru \(\mathbf{x}\) yang ingin diprediksi. Ini menghitung *seberapa mirip
3.11 Kernel Trick (Untuk Kasus Nonlinear)
Support Vector Regression (SVR) tidak terbatas pada model linier. Untuk menangani hubungan non-linier antara variabel input dan output, SVR memanfaatkan teknik yang disebut “kernel trick”.
3.11.1 Mengapa Perlu Kernel?
SVR linier hanya bisa memodelkan hubungan linier:
\[ f(\mathbf{x}) = \mathbf{w}^T \mathbf{x} + b \]
Namun, dalam banyak kasus hubungan antara variabel input-output tidak linier. Oleh karena itu, diperlukan fungsi transformasi \(\phi(\mathbf{x})\) yang memetakan data ke dimensi yang lebih tinggi:
\[ f(\mathbf{x}) = \mathbf{w}^T \phi(\mathbf{x}) + b \]
Tapi menghitung \(\phi(\mathbf{x})\) secara eksplisit bisa sangat mahal. Di sinilah kernel digunakan.
3.11.2 Apa Itu Kernel?
Fungsi kernel memungkinkan kita menghitung produk dalam ruang fitur tanpa benar-benar melakukan transformasi \(\phi(\mathbf{x})\):
\[ K(\mathbf{x}_i, \mathbf{x}_j) = \phi(\mathbf{x}_i)^T \phi(\mathbf{x}_j) \]
Dengan ini, kita bisa tetap bekerja di ruang asli tapi seolah-olah berada di ruang fitur tinggi.
3.11.3 Fungsi Kernel Umum
Beberapa kernel populer:
Linear Kernel:
\[ K(\mathbf{x}_i, \mathbf{x}_j) = \mathbf{x}_i^T \mathbf{x}_j \]Polynomial Kernel:
\[ K(\mathbf{x}_i, \mathbf{x}_j) = (\gamma \mathbf{x}_i^T \mathbf{x}_j + r)^d \]Radial Basis Function (RBF) / Gaussian Kernel:
\[ K(\mathbf{x}_i, \mathbf{x}_j) = \exp(-\gamma \|\mathbf{x}_i - \mathbf{x}_j\|^2) \]Sigmoid Kernel:
\[ K(\mathbf{x}_i, \mathbf{x}_j) = \tanh(\gamma \mathbf{x}_i^T \mathbf{x}_j + r) \]
3.11.4 Intuisi Kernel RBF
Kernel RBF memungkinkan model membuat prediksi yang sangat fleksibel dan lokal karena:
Titik yang dekat → nilai kernel mendekati 1
Titik yang jauh → nilai kernel mendekati 0
3.11.5 Implementasi SVR Kernel di R
library(e1071)
# Dataset
data(mtcars)
train_data <- mtcars[, c("hp", "mpg")]
# Model SVR dengan RBF kernel
svr_rbf <- svm(mpg ~ hp, data = train_data,
type = "eps-regression",
kernel = "radial",
cost = 10,
epsilon = 0.1)
# Buat prediksi
train_data$predicted <- predict(svr_rbf)
# Urutkan berdasarkan hp
ordered_data <- train_data[order(train_data$hp), ]
# Plot
plot(train_data$hp, train_data$mpg,
main = "SVR dengan Kernel RBF", xlab = "train_data$hp", ylab = "train_data$mpg")
lines(ordered_data$hp, ordered_data$predicted, col = "blue", lwd = 2)
3.12 Contoh Perhitungan Manual SVR Linear (5 Data)
Dataset
df_manual <- data.frame(
x = c(1, 2, 3, 4, 5),
y = c(1.9, 3.8, 2.5, 5.0, 5.8)
)
kable(df_manual, caption = "Dataset SVR Sederhana (5 Observasi)")| x | y |
|---|---|
| 1 | 1.9 |
| 2 | 3.8 |
| 3 | 2.5 |
| 4 | 5.0 |
| 5 | 5.8 |
Asumsi Model Awal
Asumsikan \(w = 1\), maka model regresi menjadi:
\[ f(x) = x + b \]
Ambil titik \((1, 1.9)\), maka:
\[ 1 + b = 1.9 \Rightarrow b = 0.9 \]
Jadi model regresi menjadi:
\[ f(x) = x + 0.9 \]
Hitung Prediksi dan Residual
epsilon <- 0.5
df_manual$y_pred <- df_manual$x + 0.9
df_manual$resid <- abs(df_manual$y - df_manual$y_pred)
df_manual$status <- ifelse(df_manual$resid <= epsilon, "Dalam Tube", "Luar Tube")
kable(df_manual, digits = 2, caption = "Prediksi, Residual, dan Status ε-Tube")| x | y | y_pred | resid | status |
|---|---|---|---|---|
| 1 | 1.9 | 1.9 | 0.0 | Dalam Tube |
| 2 | 3.8 | 2.9 | 0.9 | Luar Tube |
| 3 | 2.5 | 3.9 | 1.4 | Luar Tube |
| 4 | 5.0 | 4.9 | 0.1 | Dalam Tube |
| 5 | 5.8 | 5.9 | 0.1 | Dalam Tube |
Visualisasi SVR Manual
ggplot(df_manual, aes(x, y)) +
geom_point(size = 3) +
geom_line(aes(y = y_pred), linetype = "dotted", color = "blue") +
geom_ribbon(aes(ymin = y_pred - epsilon, ymax = y_pred + epsilon), fill = "yellow", alpha = 0.3) +
geom_text(aes(label = status), vjust = -1.2, color = "black") +
labs(title = "Visualisasi Manual SVR Linear", x = "x", y = "y") +
theme_bw()
Kesimpulan
SVR memungkinkan toleransi terhadap kesalahan kecil → menghindari overfitting
Lagrangian membantu menyusun masalah optimasi dengan kendala
Dual form memungkinkan penyelesaian efisien dan penggunaan kernel
Perhitungan manual dapat dilakukan untuk memahami dasar SVR
3.13 Contoh SVR Linear dan Nonlinear (Sederhana & Multiple) dengan R
library(e1071) # untuk SVR
library(ggplot2)
library(caret)
library(gridExtra)
set.seed(123)3.13.1 1. SVR Sederhana (1 Variabel)
A. Data Linear
# Data linear sederhana
x <- seq(-3, 3, length.out = 100)
y <- 2 * x + rnorm(100, 0, 1)
df1 <- data.frame(x = x, y = y)
# SVR Linear
svr_lin <- svm(y ~ x, data = df1, type = "eps-regression", kernel = "linear", cost = 1, epsilon = 0.1)
df1$y_pred <- predict(svr_lin, df1)
# Plot
ggplot(df1, aes(x, y)) +
geom_point(color = "gray") +
geom_line(aes(y = y_pred), color = "blue") +
labs(title = "SVR Linear (1 variabel)", x = "x", y = "y") +
theme_bw()
B. Data Nonlinea (RBF)r
# Data non-linear sederhana
x2 <- seq(-3, 3, length.out = 100)
y2 <- sin(x2) + rnorm(100, 0, 0.1)
df2 <- data.frame(x = x2, y = y2)
# SVR Nonlinear (RBF)
svr_rbf <- svm(y ~ x, data = df2, type = "eps-regression", kernel = "radial", cost = 10, epsilon = 0.1)
df2$y_pred <- predict(svr_rbf, df2)
# Plot
ggplot(df2, aes(x, y)) +
geom_point(color = "gray") +
geom_line(aes(y = y_pred), color = "red") +
labs(title = "SVR Nonlinear (1 variabel)", x = "x", y = "y") +
theme_bw()
3.13.2 2. SVR Multiple (Banyak Variabel)
A. Linear
# Data multiple linear
n <- 100
x1 <- rnorm(n)
x2 <- rnorm(n)
y <- 3 * x1 + 2 * x2 + rnorm(n, 0, 0.5)
df_multi <- data.frame(x1 = x1, x2 = x2, y = y)
# SVR Linear
svr_multi_lin <- svm(y ~ ., data = df_multi, type = "eps-regression", kernel = "linear", cost = 1, epsilon = 0.1)
df_multi$y_pred <- predict(svr_multi_lin, df_multi)
# Plot Pred vs Actual
ggplot(df_multi, aes(y, y_pred)) +
geom_point() +
geom_abline(slope = 1, intercept = 0, linetype = "dashed") +
labs(title = "SVR Linear (Multiple Variables)", x = "Actual", y = "Predicted") +
theme_bw()
B. Nonlinear (RBF)
# Data multiple nonlinear
y2 <- sin(x1 * pi) + log(abs(x2) + 1) + rnorm(n, 0, 0.2)
df_multi_nl <- data.frame(x1 = x1, x2 = x2, y = y2)
# SVR Nonlinear
svr_multi_rbf <- svm(y ~ ., data = df_multi_nl, type = "eps-regression", kernel = "radial", cost = 10, epsilon = 0.1)
df_multi_nl$y_pred <- predict(svr_multi_rbf, df_multi_nl)
# Plot Pred vs Actual
ggplot(df_multi_nl, aes(y, y_pred)) +
geom_point() +
geom_abline(slope = 1, intercept = 0, linetype = "dashed") +
labs(title = "SVR Nonlinear (Multiple Variables)", x = "Actual", y = "Predicted") +
theme_bw()
Kesimpulan - SVR linear cocok untuk data dengan pola linier.
SVR nonlinear (RBF) efektif untuk menangkap pola kompleks.
Dalam kasus multi variabel, plot Actual vs Predicted memberi indikasi kualitas model.
4 Penugasan
4.1 Penugasan 1: Support Vector Machine (SVM)
Topik: Klasifikasi Menggunakan SVM
Tujuan: Mahasiswa memahami prinsip dasar SVM untuk klasifikasi serta menerapkannya pada data nyata.
Instruksi:
Pilih satu dataset klasifikasi publik (misal: Iris, Breast Cancer, atau Penguin Dataset).
Lakukan eksplorasi data dan visualisasi awal.
Bangun model klasifikasi menggunakan:
SVM linear
SVM nonlinear (gunakan kernel RBF)
Bandingkan performa kedua model (misalnya menggunakan akurasi, precision, recall).
Visualisasikan decision boundary jika dimungkinkan (untuk 2D data).
Interpretasikan peran parameter C dan gamma.
Output:
Laporan analisis dalam format PDF/HTML dari R Markdown
Kode R yang digunakan (terstruktur dan bersih)
Kesimpulan dan refleksi hasil
4.2 Penugasan 2: Support Vector Regression (SVR)
Topik: Prediksi dan Evaluasi Model SVR
Tujuan: Mahasiswa memahami konsep epsilon-tube dan implementasi SVR dalam konteks regresi nyata.
Instruksi: 1. Pilih satu dataset regresi (misalnya: Boston Housing, mtcars, airquality, atau dataset publik lainnya).
Lakukan preprocessing data (jika perlu).
Bangun model:
SVR linear
SVR nonlinear (gunakan kernel RBF)
- Bandingkan model SVR dengan model OLS (ordinary least squares):
- Gunakan metrik: RMSE, MAE, R²
Visualisasikan epsilon-tube dan support vectors (untuk model 1D jika memungkinkan).
Eksplorasi pengaruh parameter epsilon, cost (C), dan gamma terhadap model.
Output:
Laporan analisis lengkap dalam format HTML atau PDF (dari R Markdown)
Plot visualisasi model dan residual
Interpretasi hasil dan kesimpulan aplikatif
Catatan Umum untuk Kedua Tugas: 1. Sertakan penjelasan teoretis singkat di awal laporan
Gunakan RStudio dan tulis laporan menggunakan R Markdown
Batas waktu: Rabu, 4 Juni 2025
Penilaian berdasarkan: kejelasan penulisan, kedalaman analisis, interpretasi, dan visualisasi
Referensi
Boser, B. E., Guyon, I. M., & Vapnik, V. N. (1992). A training algorithm for optimal margin classifiers. Proceedings of the Fifth Annual Workshop on Computational Learning Theory (pp. 144-152). ACM.
Cortes, C., & Vapnik, V. (1995). Support-vector networks. Machine Learning, 20(3), 273-297.
Drucker, H., Burges, C. J., Kaufman, L., Smola, A., & Vapnik, V. (1997). Support vector regression machines. Advances in Neural Information Processing Systems, 9, 155-161.
Hsu, C. W., Chang, C. C., & Lin, C. J. (2003). A practical guide to support vector classification. Technical report, National Taiwan University.
James, G., Witten, D., Hastie, T., & Tibshirani, R. (2013). An introduction to statistical learning (Vol. 112). Springer.
Schölkopf, B., & Smola, A. J. (2002). Learning with kernels: Support vector machines, regularization, optimization, and beyond. MIT press.
Vapnik, V. N. (1998). Statistical learning theory. Wiley.
Vapnik, V. (1995). The Nature of Statistical Learning Theory.
Smola, A. J., & Schölkopf, B. (2004). A tutorial on support vector regression.
5 Lampiran
5.1 Catatan: Apa itu Lagrangian?
Lagrangian adalah alat matematika yang digunakan untuk menyelesaikan masalah optimasi dengan kendala. Konsep ini penting dalam banyak bidang seperti machine learning, fisika, dan ekonomi.
5.1.1 Intuisi Sederhana
Bayangkan kamu ingin mencari titik terendah dari sebuah fungsi,
tetapi kamu tidak bisa bergerak bebas karena harus tetap berada di suatu
batasan (kendala).
Contohnya: mencari titik terdekat ke titik (0,0) yang tetap berada pada
garis \(x + y = 1\).
Contoh Sederhana
Masalah: Minimalkan:
\[ f(x, y) = x^2 + y^2 \]
Dengan kendala:
\[ x + y = 1 \]
Langkah-langkah Lagrangian:
1. Bentuk Lagrangian:
Gabungkan fungsi tujuan dan kendala menggunakan Lagrange multiplier \(\lambda\):
\[ L(x, y, \lambda) = x^2 + y^2 + \lambda (1 - x - y) \]
2. Turunkan terhadap semua variabel:
\[ \frac{\partial L}{\partial x} = 2x - \lambda = 0 \\ \frac{\partial L}{\partial y} = 2y - \lambda = 0 \\ \frac{\partial L}{\partial \lambda} = 1 - x - y = 0 \]
3. Selesaikan Sistem Persamaan:
Dari dua persamaan pertama:
\[ x = y \]
Masukkan ke persamaan kendala:
\[ x + x = 1 \Rightarrow x = y = 0.5 \]
Solusi:
Titik minimum terjadi di:
\[ (x, y) = (0.5, 0.5) \]
Nilai minimumnya:
\[ f(0.5, 0.5) = 0.5^2 + 0.5^2 = 0.5 \]
Visualisasi
library(ggplot2)
# Grid untuk fungsi f(x, y) = x² + y²
x <- seq(-1, 2, length.out = 100)
y <- seq(-1, 2, length.out = 100)
z <- outer(x, y, function(x, y) x^2 + y^2)
df <- expand.grid(x = x, y = y)
df$z <- as.vector(z)
# Garis kendala x + y = 1
constraint <- data.frame(x = seq(-1, 2, length.out = 100))
constraint$y <- 1 - constraint$x
# Plot
ggplot(df, aes(x = x, y = y)) +
geom_contour(aes(z = z), bins = 20, color = "blue", alpha = 0.5) +
geom_line(data = constraint, aes(x = x, y = y), color = "red", linewidth = 1) +
geom_point(aes(x = 0.5, y = 0.5), color = "black", size = 3) +
annotate("text", x = 0.6, y = 0.6, label = "(0.5, 0.5)", hjust = 0, size = 4) +
labs(
title = "Visualisasi Lagrangian",
subtitle = expression(paste("Kontur fungsi ", f(x, y) == x^2 + y^2, " dan kendala ", x + y == 1)),
x = "x", y = "y"
) +
theme_bw()