Lewati ke isi

Support Vector Machine (SVM)

Gambaran singkat

Apa ini? SVM mencari batas pemisah antara dua kelas dengan jarak selebar mungkin ke data terdekat dari kedua sisi.

Analogi

Dua kelompok anak di lapangan perlu dipisah dengan tali. Anda menarik tali di jalur paling longgar, sejauh mungkin dari anak terdekat di kedua sisi. Anak terdekat itulah penentu posisi tali (support vector).

Mengapa penting? SVM efektif pada data berdimensi cukup banyak dan bisa membuat batas melengkung lewat kernel. Namun pengaturannya (C, gamma) sensitif dan scaling wajib.

Yang akan dipelajari, berurutan:

  1. Ide margin maksimum dan support vector.
  2. Peran C, kernel, dan gamma.
  3. Mengapa scaling wajib dan akibat gamma yang salah.

Istilah awal:

Istilah Arti sederhana
Margin Lebar jalur kosong antara dua kelas
Support vector Data terdekat yang menentukan batas
Kernel Cara membuat batas melengkung
gamma Seberapa lokal pengaruh satu titik

Tujuan pembelajaran

  • Menjelaskan ide margin maksimum dan peran support vector.
  • Memahami C, kernel, dan gamma pada SVM RBF.
  • Menunjukkan mengapa scaling wajib dan bagaimana gamma yang salah menghancurkan model.

Intuisi

SVM mencari batas pemisah dengan margin terbesar, yaitu jarak terjauh ke sampel terdekat dari tiap kelas. Sampel yang menentukan batas itu disebut support vector; sampel lain tidak memengaruhi model. Pada data yang tidak terpisah sempurna, SVM memakai soft margin yang membolehkan sebagian pelanggaran:

\[ \min_{\mathbf{w}, b, \mathbf{\xi}}\; \frac{1}{2}\lVert \mathbf{w} \rVert^2 + C \sum_{i} \xi_i \]

\(\xi_i\) adalah besar pelanggaran margin sampel \(i\). C besar menghukum pelanggaran berat (margin sempit, risiko overfitting); C kecil menoleransi pelanggaran (margin lebar, lebih halus).

Untuk batas non-linear, SVM memakai kernel. Kernel RBF mengukur kemiripan dua titik:

\[ K(\mathbf{a}, \mathbf{b}) = \exp\!\left(-\gamma \lVert \mathbf{a} - \mathbf{b} \rVert^2\right) \]

gamma (\(\gamma\)) mengatur jangkauan pengaruh satu titik: gamma besar = pengaruh sangat lokal (batas berliku, risiko overfitting), gamma kecil = pengaruh luas (batas halus).

Ringkasan model

Aspek Keterangan
Kelebihan Efektif pada data berdimensi tinggi dan berukuran kecil–menengah; batas non-linear lewat kernel
Keterbatasan Lambat pada data sangat besar, sensitif terhadap C/gamma dan scaling, tidak langsung memberi probabilitas
Hyperparameter penting C, kernel, gamma
Praproses Scaling wajib
Cocok untuk Data tabular kecil–menengah berdimensi tinggi; pembanding kuat

Implementasi langkah demi langkah

Program examples/classification/svm.py memakai data Breast Cancer; pemuatan dan pembagian datanya sama dengan pelajaran dasar klasifikasi.

Langkah 1: fungsi bantu dan membandingkan kernel

Tujuan. Membandingkan kernel linear dan RBF, serta melihat pengaruh scaling.

svm.py
def cv_acc(model):
    return cross_val_score(model, X_train, y_train, cv=5).mean()


# 1. Kernel linear vs RBF, dengan dan tanpa scaling
print("model                      akurasi_CV")
print(f"linear + scaling           {cv_acc(make_pipeline(StandardScaler(), SVC(kernel='linear'))):.3f}")
print(f"RBF + scaling              {cv_acc(make_pipeline(StandardScaler(), SVC(kernel='rbf'))):.3f}")
print(f"RBF tanpa scaling          {cv_acc(SVC(kernel='rbf')):.3f}")
Kode Penjelasan
def cv_acc(model): return cross_val_score(...).mean() Fungsi bantu: menerima sebuah model dan mengembalikan akurasi validasi silang 5 lipatan pada data latih. Dengan fungsi ini, baris yang sama tidak perlu ditulis berulang. model adalah parameter fungsi, dan nilai setelah return adalah keluarannya.
SVC(kernel='linear') SVM dengan kernel linear: batas pemisah berupa bidang lurus.
SVC(kernel='rbf') Kernel RBF (radial basis function): batas dapat melengkung. Ini nilai bawaan.
make_pipeline(StandardScaler(), SVC(...)) SVM berbasis jarak sehingga scaling wajib; di baris terakhir sengaja tidak dipakai untuk perbandingan.
model                      akurasi_CV
linear + scaling           0.967
RBF + scaling              0.971
RBF tanpa scaling          0.910

Interpretasi. Kernel linear 0,967, RBF 0,971, dan RBF tanpa scaling hanya 0,910: fitur berskala besar mendominasi perhitungan jarak, sama seperti pada KNN.

Langkah 2: pengaruh C dan gamma

Konsep. C mengatur toleransi pelanggaran margin (besar = margin sempit, risiko overfitting). gamma mengatur jangkauan pengaruh satu titik pada kernel RBF (besar = sangat lokal). Keduanya adalah hyperparameter: ditetapkan sebelum pelatihan.

svm.py
# 2. Pengaruh C dan gamma pada kernel RBF (gamma besar = pengaruh titik sangat lokal)
print("\nC      gamma   akurasi_latih  akurasi_CV")
for C, gamma in [(1, 0.001), (1, "scale"), (1, 1.0), (100, 0.001), (100, "scale"), (100, 1.0)]:
    model = make_pipeline(StandardScaler(), SVC(C=C, gamma=gamma))
    train_acc = model.fit(X_train, y_train).score(X_train, y_train)
    print(f"{C:<6} {str(gamma):<7} {train_acc:.3f}          {cv_acc(model):.3f}")
Kode Penjelasan
for C, gamma in [(1, 0.001), ...] Mengulang daftar pasangan (C, gamma); tiap pasangan langsung dipecah ke dua variabel.
gamma="scale" Nilai otomatis scikit-learn: \(1/(\text{jumlah fitur} \times \text{varians } X)\). Titik awal yang masuk akal.
model.fit(...).score(X_train, y_train) Akurasi latih; dibandingkan dengan akurasi validasi silang untuk mendiagnosis overfitting.
C      gamma   akurasi_latih  akurasi_CV
1      0.001   0.952          0.947
1      scale   0.982          0.971
1      1.0     1.000          0.631
100    0.001   0.987          0.978
100    scale   1.000          0.958
100    1.0     1.000          0.635

Interpretasi.

  • gamma=1.0: akurasi latih 1,000 tetapi validasi silang 0,631 (nyaris proporsi kelas mayoritas 0,626): setiap titik hanya memengaruhi tetangga sangat dekat sehingga model menghafal data latih dan gagal pada data baru, contoh overfitting ekstrem.
  • C=1, gamma=0,001: model terlalu halus (latih 0,952; CV 0,947).
  • Kombinasi terbaik pada tabel kecil ini: C=100, gamma=0,001 (CV 0,978); C=1, gamma="scale" (0,971) hampir setara.
  • C=100 dengan gamma="scale" justru turun (0,958): C dan gamma berinteraksi sehingga harus disetel bersama (lihat Optimasi Hyperparameter).

Langkah 3: evaluasi akhir dan support vector

svm.py
# 3. Evaluasi akhir (RBF, C=1, gamma="scale") dan jumlah support vector
final = make_pipeline(StandardScaler(), SVC(C=1, gamma="scale")).fit(X_train, y_train)
print("\njumlah support vector per kelas:", final[-1].n_support_.tolist(), "dari", len(X_train), "data latih")
print(classification_report(y_test, final.predict(X_test), digits=3))

final[-1] adalah langkah terakhir pipeline (objek SVC); n_support_ adalah jumlah support vector per kelas (atribut berakhiran _ = hasil pelatihan). .tolist() mengubah array menjadi list agar tercetak ringkas.

jumlah support vector per kelas: [51, 46] dari 455 data latih
              precision    recall  f1-score   support

           0      0.976     0.976     0.976        42
           1      0.986     0.986     0.986        72

    accuracy                          0.982       114
   macro avg      0.981     0.981     0.981       114
weighted avg      0.982     0.982     0.982       114

Interpretasi. 97 dari 455 data latih (51 kelas ganas, 46 kelas jinak) menjadi support vector, yaitu sampel yang menentukan batas keputusan; sampel lain tidak memengaruhi model. Pada data uji akurasi 0,982, setara regresi logistik pada data ini.

Program lengkap (svm.py)
svm.py
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

SEED = 42
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)


def cv_acc(model):
    return cross_val_score(model, X_train, y_train, cv=5).mean()


# 1. Kernel linear vs RBF, dengan dan tanpa scaling
print("model                      akurasi_CV")
print(f"linear + scaling           {cv_acc(make_pipeline(StandardScaler(), SVC(kernel='linear'))):.3f}")
print(f"RBF + scaling              {cv_acc(make_pipeline(StandardScaler(), SVC(kernel='rbf'))):.3f}")
print(f"RBF tanpa scaling          {cv_acc(SVC(kernel='rbf')):.3f}")

# 2. Pengaruh C dan gamma pada kernel RBF (gamma besar = pengaruh titik sangat lokal)
print("\nC      gamma   akurasi_latih  akurasi_CV")
for C, gamma in [(1, 0.001), (1, "scale"), (1, 1.0), (100, 0.001), (100, "scale"), (100, 1.0)]:
    model = make_pipeline(StandardScaler(), SVC(C=C, gamma=gamma))
    train_acc = model.fit(X_train, y_train).score(X_train, y_train)
    print(f"{C:<6} {str(gamma):<7} {train_acc:.3f}          {cv_acc(model):.3f}")

# 3. Evaluasi akhir (RBF, C=1, gamma="scale") dan jumlah support vector
final = make_pipeline(StandardScaler(), SVC(C=1, gamma="scale")).fit(X_train, y_train)
print("\njumlah support vector per kelas:", final[-1].n_support_.tolist(), "dari", len(X_train), "data latih")
print(classification_report(y_test, final.predict(X_test), digits=3))

Kesalahan umum

Hindari

  • Memakai SVM tanpa scaling.
  • Memilih gamma terlalu besar sehingga model menghafal.
  • Menyetel C dan gamma terpisah padahal keduanya berinteraksi.
  • Menggunakan SVM kernel pada data sangat besar tanpa mempertimbangkan waktu pelatihan.
  • Menganggap decision_function sebagai probabilitas.

Latihan

  1. Coba kernel="poly" dengan degree=2 dan degree=3.
  2. Tambahkan class_weight="balanced". Apakah recall kelas ganas berubah?
  3. Hitung jumlah support vector untuk C=0,1 dan C=100. Mana yang lebih banyak, dan mengapa?

Ringkasan

SVM memaksimalkan margin; C mengatur toleransi pelanggaran dan gamma jangkauan pengaruh titik pada kernel RBF. Scaling wajib, dan C serta gamma perlu disetel bersama.

Berikutnya: Naive Bayes.