Support Vector Regression (SVR)

Regresi dengan "Toleransi Kesalahan"

1. Apa itu SVR?

Jika Regresi Linear berusaha meminimalkan error semua titik data, SVR memiliki pendekatan unik: Ia berusaha memasukkan sebanyak mungkin titik data ke dalam sebuah "jalan raya" (Tube) dengan lebar tertentu ($\epsilon$).

SVR tidak peduli dengan error sekecil apa pun selama error tersebut masih berada di dalam batas toleransi ($\epsilon$). Hanya titik-titik yang berada di luar jalan raya inilah yang disebut Support Vectors dan mempengaruhi pembentukan garis model.

Analogi: Bayangkan Anda membangun jalan raya lurus. Anda tidak peduli rumah-rumah yang ada di pinggir jalan (di dalam bahu jalan). Anda hanya peduli dengan rumah yang terlalu jauh (melanggar batas) agar jalan raya bisa digeser mendekati mereka.

2. Visualisasi Konsep $\epsilon$-Tube

  • Garis Biru Hyperplane ($f(x)$): Garis prediksi kita.
  • Garis Merah Putus-putus Batas ($\epsilon$): Area toleransi. $y \pm \epsilon$.
  • Titik Hitam Data Normal: Di dalam tube. Error dianggap 0.
  • Titik Merah Support Vectors: Di luar tube. Ini yang dihitung errornya ($\xi$).

Ilustrasi Epsilon-Insensitive Tube

3. Matematika SVR (Disederhanakan)

Tujuan SVR adalah meminimalkan:

$$ \frac{1}{2} ||w||^2 + C \sum_{i=1}^{n} (\xi_i + \xi_i^*) $$
Komponen 1: Regularization

$$ \frac{1}{2} ||w||^2 $$

Bugs agar garis prediksi "datar" (flatness) dan tidak terlalu meliuk-liuk (mencegah overfitting).

Komponen 2: Error Penalty

$$ C \sum (\xi_i) $$

Menghukum titik-titik yang keluar dari tube.
$C$ (Cost): Parameter tuning.
- $C$ Besar: Hukuman berat, tube akan berusaha mencakup semua outlier (rawan overfitting).
- $C$ Kecil: Hukuman ringan, tube lebih longgar (lebih smooth).

4. Simulasi Perhitungan Manual

Karena rumus asli SVR melibatkan Quadratic Programming yang rumit, kita akan mensimulasikan bagaimana SVR menghitung Error/Penalty untuk sebuah garis kandidat.

Skenario:
  • Kita punya 3 data: A(1, 1.5), B(2, 2.0), C(3, 4.0).
  • Kita mencoba garis model: $f(x) = 1x + 0.5$ (Slope=1, Intercept=0.5).
  • Kita tetapkan toleransi $\epsilon = 0.5$.
Titik Asli ($y$) Prediksi ($f(x)$) Error ($|y - f(x)|$) Status ($\epsilon=0.5$) Penalty ($\xi$)
A($1$) 1.5 $1(1)+0.5 = \mathbf{1.5}$ $|1.5 - 1.5| = 0$ Aman (0 < 0.5) 0
B($2$) 2.0 $1(2)+0.5 = \mathbf{2.5}$ $|2.0 - 2.5| = 0.5$ Pas Batas (0.5 = 0.5) 0
C($3$) 4.0 $1(3)+0.5 = \mathbf{3.5}$ $|4.0 - 3.5| = 0.5$ Melanggar! (0.5 > 0.5)
Oops, tunggu... 		0
Revisi Kasus Titik C:
Mari kita ubah Titik C menjadi (3, 4.5) agar terlihat bedanya.
Prediksi: $3.5$.
Error: $|4.5 - 3.5| = \mathbf{1.0}$.
Karena Error ($1.0$) > Toleransi ($\epsilon=0.5$), maka:
Penalty ($\xi$) = Error - $\epsilon = 1.0 - 0.5 = 0.5$.

Total Cost untuk garis ini adalah kombinasi dari:
1. Flatness: $\frac{1}{2}||w||^2 = 0.5(1)^2 = 0.5$.
2. Penalty: $C \times \xi_{total}$. Jika $C=1$, maka $1 \times 0.5 = 0.5$.
Total Loss = 0.5 + 0.5 = 1.0.

SVR akan mencoba ribuan kemungkinan garis lain untuk mencari Total Loss yang paling kecil.

5. Kernel Trick (Senjata Rahasia)

Kekuatan utama SVR adalah kemampuannya menangani data Non-Linear tanpa menambah kompleksitas model secara signifikan, menggunakan fungsi Kernel.

Kernel memetakan data dari dimensi rendah (2D) ke dimensi tinggi (3D) dimana data tersebut bisa dipisahkan secara linear.

Jenis Kernel Deskripsi Kapan Dipakai?
Linear Garis lurus biasa. Efisien. Data hubungan sederhana (Gaji vs Pengalaman).
RBF (Radial Basis Function) Kurva lonceng tak terbatas. Paling populer. Data kompleks, pola tidak beraturan (Saham, Cuaca).
Polynomial Kurva lengkung derajat tertentu. Data melengkung spesifik (Pertumbuhan bakteri).

6. Implementasi Python (Scikit-Learn)

Kita akan menggunakan `SVR` dari `sklearn.svm`.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler

# 1. Generate Data Dummy yang Melengkung (Non-Linear)
X = np.sort(5 * np.random.rand(40, 1), axis=0)
y = np.sin(X).ravel()
# Tambah sedikit noise acak
y[::5] += 3 * (0.5 - np.random.rand(8))

# 2. Scaling (PENTING UNTUK SVR!)
# SVR sangat sensitif terhadap skala data.
sc_X = StandardScaler()
sc_y = StandardScaler()
X_scaled = sc_X.fit_transform(X)
y_scaled = sc_y.fit_transform(y.reshape(-1, 1)).ravel()

# 3. Buat Model SVR dengan Kernel RBF
# C=1.0 : Regularisasi
# epsilon=0.1 : Lebar tube
svr_rbf = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
svr_lin = SVR(kernel='linear', C=100, gamma='auto')

# 4. Training
svr_rbf.fit(X_scaled, y_scaled)
svr_lin.fit(X_scaled, y_scaled)

# 5. Prediksi
y_pred_rbf = sc_y.inverse_transform(svr_rbf.predict(X_scaled).reshape(-1,1))
y_pred_lin = sc_y.inverse_transform(svr_lin.predict(X_scaled).reshape(-1,1))

print("Selesai Training. Model RBF akan mengikuti kurva sinus.")
Catatan Penting: SVR WAJIB menggunakan Feature Scaling (StandardScaler) karena ia menghitung jarak antar titik. Jika skala data beda jauh (misal: Gaji=Jutaan, Umur=Puluhan), model akan gagal total.