STA1382 Support Vector Machine

Cahya Alkahfi | Rizki Ananda

Pendahuluan

Support Vector Machine (SVM) adalah algoritma pembelajaran mesin yang digunakan untuk masalah klasifikasi dan regresi. SVM mencari hyperplane (bidang pemisah) terbaik yang memisahkan kelas data yang berbeda dengan jarak maksimum antara kelas. SVM dapat digunakan untuk memproses data yang memiliki fitur berdimensi tinggi dan dapat menangani masalah klasifikasi biner (dua kelas) maupun multi-kelas.

Konsep dasar di balik SVM adalah mencari hyperplane optimal yang dapat memaksimalkan margin antara dua kelas data. Margin adalah jarak antara hyperplane dan titik terdekat dari setiap kelas. SVM memilih hyperplane yang memberikan margin maksimum antara kelas, dengan harapan dapat memperbaiki kinerja model saat memprediksi data baru.

SVM juga menggunakan kernel function yang memetakan data ke ruang dimensi yang lebih tinggi, di mana data dapat lebih mudah dipisahkan. Contohnya, kernel dapat digunakan untuk memetakan data linier yang tidak dapat dipisahkan secara linier ke dalam dimensi yang lebih tinggi agar dapat dipisahkan dengan hyperplane.

Kegunaan

SVM adalah algoritma yang sangat fleksibel dan dapat diterapkan dalam berbagai bidang yang membutuhkan pengolahan data. Beberapa kegunaan SVM antara lain:

Klasifikasi: SVM digunakan untuk memisahkan data menjadi kelas yang berbeda, misalnya untuk mengklasifikasikan email sebagai spam atau tidak spam, atau untuk membedakan antara gambar kucing dan anjing.
Regresi: SVM dapat digunakan untuk memprediksi nilai numerik, misalnya untuk memprediksi harga rumah berdasarkan fitur seperti lokasi, ukuran, dan jumlah kamar tidur.
Deteksi anomali: SVM digunakan untuk mendeteksi anomali atau pencilan dalam data, misalnya dalam deteksi fraud pada transaksi kartu kredit atau dalam mendeteksi kecelakaan pesawat.
Clustering: SVM digunakan untuk mengelompokkan data ke dalam kelompok yang berbeda, seperti dalam pengelompokan data pelanggan berdasarkan preferensi atau perilaku belanja.
Analisis citra: SVM digunakan dalam pengolahan citra untuk membedakan antara objek dan latar belakang dalam gambar, atau untuk mengklasifikasikan jenis objek dalam gambar.
Bioinformatika: SVM digunakan dalam bioinformatika untuk memprediksi protein atau untuk mengklasifikasikan tipe sel berdasarkan fitur seperti ukuran dan bentuk.

Kelebihan dan Kekurangan

Kelebihan SVM:

Efektif pada data yang kompleks: SVM dapat bekerja dengan baik pada data yang sangat kompleks dengan banyak fitur dan tidak teratur.
Menangani masalah kelas yang tidak seimbang: SVM dapat menangani masalah kelas yang tidak seimbang dengan memperhatikan kelas minoritas dan mengoptimalkan margin untuk kelas tersebut.
Toleran terhadap overfitting: SVM dapat mengurangi risiko overfitting dengan menggunakan parameter yang tepat dan teknik kernel.
Tepat dan akurat: SVM merupakan salah satu algoritma pembelajaran mesin yang memiliki tingkat akurasi yang sangat baik dalam masalah klasifikasi dan regresi.
Dapat mengatasi masalah dengan dimensi yang tinggi: SVM efektif dalam menangani masalah dengan fitur berdimensi tinggi, seperti pada data citra dan teks.

Kekurangan SVM:

Memiliki kompleksitas perhitungan yang tinggi: SVM membutuhkan waktu komputasi yang lama pada data yang sangat besar, sehingga dapat memakan waktu yang lama untuk proses pelatihan.
Memerlukan tuning parameter yang tepat: SVM memerlukan tuning parameter yang tepat untuk mengoptimalkan kinerja model. Jika parameter tidak dipilih dengan benar, kinerja model dapat menurun.
Tidak dapat menangani data yang hilang: SVM tidak dapat menangani data yang hilang atau data yang tidak lengkap.
Tidak cocok untuk data non-linier: SVM mungkin tidak efektif untuk data yang tidak dapat dipisahkan secara linier jika tidak menggunakan teknik kernel.
Tidak cocok untuk aplikasi online: SVM memerlukan waktu pelatihan yang lama, sehingga tidak cocok untuk aplikasi yang memerlukan pelatihan model secara online atau real-time.

Jenis SVM

Ada beberapa jenis SVM yang dibedakan pada kernel dan parameter yang digunakan, dan cara mendefinisikan hyperplane. Beberapa jenis SVM yang umum digunakan adalah sebagai berikut:

Linear SVM: Linear SVM mencari hyperplane linier yang memisahkan kelas dengan jarak maksimum. Linear SVM efektif untuk data yang dapat dipisahkan secara linier. Linear SVM menggunakan fungsi kernel linier untuk memisahkan kelas dalam ruang fitur. Linear SVM lebih cepat dan lebih cocok untuk dataset dengan fitur yang tidak terlalu kompleks.
Non-Linear SVM: Non-Linear SVM menggunakan fungsi kernel non-linier untuk memisahkan kelas dalam ruang fitur yang tidak linear. Non-Linear SVM efektif untuk data yang tidak dapat dipisahkan secara linier. Beberapa jenis kernel non-linear yang digunakan pada SVM adalah kernel polinomial, kernel radial basis function (RBF), dan kernel sigmoid.
SVM kernel radial basis function (RBF): SVM RBF menggunakan kernel RBF untuk memetakan data ke dalam dimensi yang lebih tinggi, dan kemudian mencari hyperplane yang memisahkan kelas. SVM RBF efektif untuk data yang memiliki banyak fitur dan tidak teratur.
One-Class SVM: One-Class SVM adalah variasi SVM yang digunakan untuk deteksi outlier. One-Class SVM mencoba untuk mempelajari model dari satu kelas data saja (kelas yang normal) dan kemudian menggunakan model ini untuk mengidentifikasi data yang bukan dari kelas tersebut (outlier).
Multi-Class SVM: Multi-Class SVM dapat menangani masalah dengan lebih dari dua kelas. Multi-Class SVM menggunakan teknik seperti one-vs-all atau one-vs-one untuk memecahkan masalah klasifikasi multi-kelas.
Support Vector Regression (SVR): SVR adalah variasi SVM untuk regresi yang menggunakan margin sebagai batasan toleransi kesalahan dalam prediksi. SVR mencoba untuk meminimalkan jumlah titik data yang jatuh di luar margin batas toleransi kesalahan. SVR digunakan untuk memprediksi nilai numerik, dengan mencari hyperplane yang memberikan nilai prediksi yang paling dekat dengan nilai yang sebenarnya.
Semi Supervised Support Vector Machine (S3VM): SVM yang standar (biasa) hanya diterapkan pada supervised learning. S3VM digunakan dalam kasus-kasus di mana data yang tersedia sebagian besar tidak berlabel atau hanya sebagian kecil yang berlabel. Dalam pembelajaran mesin tradisional, model yang dihasilkan hanya dapat belajar dari data yang memiliki label, yang mana label tersebut memberikan informasi mengenai kelas mana data tersebut termasuk. Namun, di dunia nyata, seringkali sulit dan mahal untuk mengumpulkan data yang berlabel secara lengkap. Oleh karena itu, S3VM digunakan untuk memanfaatkan data yang tidak berlabel atau kurang berlabel untuk meningkatkan akurasi klasifikasi.

Terminologi pada SVM

Berikut adalah beberapa terminologi umum pada SVM:

Kernel: Fungsi kernel digunakan untuk memetakan data ke dalam dimensi yang lebih tinggi, di mana data dapat lebih mudah dipisahkan. Beberapa jenis kernel yang umum digunakan adalah linear, polynomial, dan radial basis function (RBF).
Hyperplane: Hyperplane adalah batas keputusan yang memisahkan kelas pada ruang fitur. Dalam kasus SVM linier, hyperplane adalah garis, sedangkan dalam SVM non-linier, hyperplane dapat berupa permukaan yang kompleks.
Support vector: Support vector adalah data yang paling dekat dengan hyperplane dan mempengaruhi lokasi hyperplane. Support vector digunakan dalam perhitungan margin dan dalam menentukan koefisien pembobotan.
Margin: Margin adalah jarak antara hyperplane dan support vector yang terdekat. Margin harus maksimum agar kelas dapat dipisahkan dengan jarak yang optimal.
C: Parameter C (Cost) pada SVM digunakan untuk mengontrol penalti pada kesalahan klasifikasi. C yang lebih besar akan memperbolehkan lebih banyak kesalahan klasifikasi pada data pelatihan, sedangkan C yang lebih kecil akan menghasilkan model yang lebih rumit dan lebih sensitif terhadap kesalahan.
Gamma: Parameter gamma pada SVM digunakan dalam kernel RBF untuk mengontrol bentuk hyperplane. Gamma yang lebih besar akan menghasilkan hyperplane yang lebih kompleks dan lebih sensitif terhadap data pelatihan, sedangkan gamma yang lebih kecil akan menghasilkan hyperplane yang lebih sederhana dan lebih bias terhadap data yang tidak terlihat.

Konsep Dasar

Konsep dasar SVM adalah mencari hyperplane terbaik yang dapat memisahkan dua kelas data dengan jarak maksimum. SVM memerlukan data pelatihan untuk menemukan hyperplane terbaik. Data pelatihan terdiri dari pasangan input dan output, di mana input adalah fitur atau atribut dari suatu objek, dan output adalah label atau kelas objek tersebut. SVM kemudian memetakan data pelatihan ke dalam ruang fitur yang lebih tinggi menggunakan teknik kernel, seperti kernel linear, kernel polinomial, atau kernel radial.

Setelah data pelatihan dipetakan ke dalam ruang fitur yang lebih tinggi, SVM mencari hyperplane terbaik yang dapat memisahkan kelas data dengan jarak maksimum. Hyperplane terbaik adalah hyperplane yang memiliki margin terbesar di antara semua kemungkinan hyperplane.

SVM juga memiliki parameter yang dapat diatur untuk mengoptimalkan kinerjanya, seperti parameter C yang mengatur trade-off antara margin dan kesalahan klasifikasi, dan parameter kernel yang menentukan jenis kernel yang digunakan untuk memetakan data ke dalam ruang fitur yang lebih tinggi.

SVM dapat digunakan pada masalah klasifikasi biner dan multikelas, serta dapat menangani data yang tidak dapat dipisahkan secara linier dengan menggunakan teknik kernel. SVM juga dapat digunakan pada data dengan jumlah fitur yang besar, karena SVM hanya menggunakan subset dari data pelatihan yang merupakan support vector. Namun, SVM sensitif terhadap keberadaan pencilan (outlier) dan dapat menghasilkan model yang kompleks jika terlalu banyak fitur atau jika parameter kernel yang tidak tepat digunakan.

Hyperplane

Hyperplane pada SVM adalah batas keputusan yang memisahkan kelas pada ruang fitur. Hyperplane didefinisikan oleh model SVM sebagai fungsi linear atau non-linear yang digunakan untuk mengklasifikasikan data. Dalam SVM linier, hyperplane adalah garis linear yang memisahkan dua kelas data. Namun, dalam SVM non-linier, hyperplane bisa berbentuk permukaan yang kompleks untuk memisahkan kelas data.

Hyperplane dihitung dalam SVM dengan menggunakan pembobotan dari setiap fitur pada data pelatihan. Pembobotan ini disebut vektor pembobotan, yang disesuaikan selama proses pelatihan untuk meminimalkan kesalahan klasifikasi dan memaksimalkan jarak margin antara kelas.

Hyperplane memiliki peran yang penting dalam SVM, karena dapat membantu membedakan kelas data dengan jelas. Oleh karena itu, SVM berusaha untuk menemukan hyperplane yang optimal, yang memisahkan kelas data dengan jarak maksimum. Margin adalah jarak antara hyperplane dan support vector terdekat, dan SVM berusaha untuk memaksimalkan margin ini agar kelas dapat dipisahkan dengan jarak yang optimal. Dengan kata lain, SVM mencari hyperplane terbaik yang memaksimalkan margin antara kelas data sehingga memberikan keputusan klasifikasi yang lebih akurat pada data baru yang belum pernah dilihat sebelumnya.

Maximal Margin Classifier

Margin pada SVM adalah jarak antara hyperplane dan support vector terdekat, yaitu titik-titik pada kelas yang paling dekat dengan hyperplane. Maximal Margin Classifier mencari hyperplane yang memiliki margin terbesar di antara semua kemungkinan hyperplane. Dengan kata lain, Maximal Margin Classifier mencari hyperplane yang memisahkan kelas dengan jarak maksimum, sehingga dapat mengurangi kemungkinan terjadinya kesalahan klasifikasi.

Proses Maximal Margin Classifier dimulai dengan memilih dua support vector terdekat, yaitu titik-titik pada masing-masing kelas yang paling dekat dengan hyperplane. Kemudian, margin dihitung sebagai jarak antara kedua support vector tersebut. Maximal Margin Classifier akan mencari hyperplane yang memisahkan kelas dengan jarak maksimum di antara semua kemungkinan hyperplane yang memenuhi syarat bahwa semua data berada di sisi yang benar dari hyperplane.

Maximal Margin Classifier dapat digunakan pada data yang dapat dipisahkan secara linier. Namun, pada kelas data yang tidak dapat dipisahkan secara linier, SVM non-linier dapat digunakan untuk menemukan hyperplane yang memisahkan kelas data dengan maksimal menggunakan teknik kernel. Dalam SVM non-linier, Maximal Margin Classifier mencari hyperplane terbaik yang memisahkan kelas dengan margin maksimum pada ruang fitur yang lebih tinggi setelah dilakukan pemetaan oleh fungsi kernel.

Keuntungan dari Maximal Margin Classifier adalah dapat menghasilkan model SVM yang lebih stabil dan memiliki tingkat kesalahan klasifikasi yang lebih rendah. Namun, kekurangan dari pendekatan ini adalah sensitif terhadap pencilan (outlier) yang dapat mempengaruhi posisi hyperplane dan margin.

Data yang terpisah sempurna

# Attach Packages
library(tidyverse)    # data manipulation and visualization
library(kernlab)      # SVM methodology
library(e1071)        # SVM methodology
library(ISLR)         # contains example data set "Khan"
library(RColorBrewer) # customized coloring of plots
library(caret)

set.seed(10)
# Construct sample data set - completely separated
x <- matrix(rnorm(20*2), ncol = 2)
y <- c(rep(-1,10), rep(1,10))
x[y==1,] <- x[y==1,] + 3/2
dat <- data.frame(x=x, y=as.factor(y))

# Plot data
ggplot(data = dat, aes(x = x.2, y = x.1, color = y, shape = y)) + 
  geom_point(size = 2) +
  scale_color_manual(values=c("#000000", "#FF0000")) +
  theme(legend.position = "none")

Tujuan dari maximal margin classifier adalah untuk mengidentifikasi batas linier yang memaksimalkan total jarak antara garis dan titik terdekat di setiap kelas. Kita dapat menggunakan fungsi svm() dalam paket e1071 untuk menemukan batasan ini.

Pada plot di atas, titik-titik yang diwakili oleh “X” adalah vektor pendukung, atau titik-titik yang secara langsung mempengaruhi garis klasifikasi. Titik yang ditandai dengan “o” adalah titik lainnya, yang tidak mempengaruhi perhitungan garis.

# Fit Support Vector Machine model to data set
svmfit <- svm(y~., data = dat, kernel = "linear", scale = FALSE)
# Plot Results
plot(svmfit, dat)

Support Vector Classifier (SVC)

Pada suatu kasus bisa saja kelas tidak dapat dipisahkan oleh hyperplane sehingga maximal marginal classifier tidak dapat digunakan. Generalisasi dari maximal margin classifier ke kasus yang tidak dapat dipisahkan dikenal sebagai support vector classifier. Dalam hal ini, kita mungkin bersedia mempertimbangkan classifier berdasarkan hyperplane yang tidak memisahkan dua kelas dengan sempurna, untuk kepentingan:

ketahanan (robustness) yang lebih besar untuk pengamatan individu,
klasifikasi yang lebih baik dari sebagian besar pengamatan data training

Artinya, mungkin lebih bermanfaat untuk salah mengklasifikasikan beberapa pengamatan data training untuk melakukan pekerjaan yang lebih baik dalam mengklasifikasikan pengamatan yang tersisa (data testing).

Berbeda dengan SVM yang mencari hyperplane yang memaksimalkan margin antara kelas, SVC mencari hyperplane yang dapat memisahkan kelas dengan menggunakan kriteria error minimal.

SVC dapat digunakan untuk menyelesaikan masalah klasifikasi biner dan multikelas. Proses pembelajaran SVC dimulai dengan memilih hyperplane awal secara acak, kemudian menghitung kesalahan klasifikasi pada data pelatihan. Setelah itu, SVC memperbaiki hyperplane dengan meminimalkan kesalahan klasifikasi yang dihasilkan. SVC menggunakan teknik optimasi matematis untuk menemukan hyperplane terbaik yang dapat memisahkan kelas dengan kesalahan minimal.

Sama seperti SVM, SVC juga menggunakan support vector sebagai titik-titik pada kelas yang paling dekat dengan hyperplane. Namun, dalam SVC, support vector dapat berada di sisi hyperplane yang salah, karena SVC hanya mencoba meminimalkan kesalahan klasifikasi dan tidak memaksimalkan margin.

Keuntungan dari SVC adalah dapat menangani data yang tidak dapat dipisahkan secara linier, karena SVC menggunakan teknik kernel untuk memetakan data ke dalam dimensi yang lebih tinggi. Selain itu, SVC juga dapat digunakan pada dataset dengan jumlah fitur yang besar, karena SVC hanya menggunakan subset dari data pelatihan yang merupakan support vector. Kekurangan dari SVC adalah sensitif terhadap keberadaan pencilan (outlier) dan dapat menghasilkan model yang kompleks jika terlalu banyak fitur atau jika parameter kernel yang tidak tepat digunakan.

Data yang tidak dapat dipisah sempurna

# Construct sample data set - not completely separated
x <- matrix(rnorm(20*2), ncol = 2)
y <- c(rep(-1,10), rep(1,10))
x[y==1,] <- x[y==1,] + 1
dat <- data.frame(x=x, y=as.factor(y))

# Plot data set
ggplot(data = dat, aes(x = x.2, y = x.1, color = y, shape = y)) + 
  geom_point(size = 2) +
  scale_color_manual(values=c("#000000", "#FF0000")) +
  theme(legend.position = "none")

Dalam kasus data yang tidak dapat dipisahkan secara sempurna, argumen cost = menjadi sangat penting. Ini menghitung penalti yang terkait dengan pengamatan di sisi yang salah dari batas klasifikasi.

Kernel Linier

# Fit Support Vector Machine model to data set
svmfit <- svm(y~., data = dat, kernel = "linear", cost = 10)
# Plot Results
plot(svmfit, dat)

Kernel Polynomial

svmfit2 <- svm(y~., data = dat, kernel = "polynomial", gamma = 2, cost = 10)
# Plot Results
plot(svmfit2, dat)

Kernel Radial

svmfit3 <- svm(y~., data = dat, kernel = "radial", gamma = 2)
# Plot Results
plot(svmfit3, dat)

Kernel Sigmoid

svmfit4 <- svm(y~., data = dat, kernel = "sigmoid", gamma = 2, cost = 10)
# Plot Results
plot(svmfit4, dat)

Dari keempat bentuk SVM di atas, terlihat SVM bisa membuat batas yang berbeda-beda, namun tidak semuanya baik dalam memisahkan data. Jadi jenis pemisah yang digunakan harus juga juga sesuai (Atau dicek kesesuainya dengan data yang ada).

Support Vector Machines (SVM)

Support vector classifier adalah pendekatan alami untuk klasifikasi dalam pengaturan dua kelas, jika batas antara kedua kelas adalah linier. Namun, dalam praktiknya kita terkadang dihadapkan pada batasan kelas yang tidak linier. Dalam kasus support vector classifier, kita dapat mengatasi masalah kemungkinan batas non-linear antar kelas dengan cara memperbesar ruang fitur menggunakan fungsi polinomial kuadrat, kubik, dan bahkan orde lebih tinggi dari prediktor (fungsi polynomial dari variabel prediktor). Tidak sulit untuk melihat bahwa ada banyak cara yang memungkinkan untuk memperbesar ruang fitur, dan jika kita tidak hati-hati, kita bisa mendapatkan banyak fitur. Kemudian perhitungan akan menjadi tidak terkendali. Support vector machines, memungkinkan untuk memperbesar ruang fitur yang digunakan oleh support vector classifier dengan cara yang mengarah pada komputasi yang efisien.

Berikutnya kita akan melakukan ilustrasi menggunakan data non-linear. Untuk kernel polinomial kita menggunakan parameter degree untuk menyesuaikan urutan polinomial. Untuk kernel radial kita menggunakan parameter gamma untuk menyesuaikan nilai y.

# Generate some test data
set.seed (100)
x <- matrix(rnorm(200*2), ncol=2)
x[1:100,]=x[1:100,]+2
x[101:150,]=x[101:150,]-2

y <- c(rep(1,150),rep(2,50))
dat <- data.frame(x=x,y=as.factor(y))

plot(x, col=y)

Berikutnya split data secara acak menjadi data latih dan data uji. Dan lakukan pemodelan dengan kernel radial karena berdasarkan plot dapat dilihat bahwa pengelompokan data berbentuk radial.

set.seed(100)
train <- sample(200, 100)

svm.fit <- svm(y ~., data=dat[train,], kernel='radial', gamma=1, cost=1)

plot(svm.fit, dat[train,])

summary(svm.fit)

## 
## Call:
## svm(formula = y ~ ., data = dat[train, ], kernel = "radial", gamma = 1, 
##     cost = 1)
## 
## 
## Parameters:
##    SVM-Type:  C-classification 
##  SVM-Kernel:  radial 
##        cost:  1 
## 
## Number of Support Vectors:  32
## 
##  ( 18 14 )
## 
## 
## Number of Classes:  2 
## 
## Levels: 
##  1 2

yhat <- predict(svm.fit, dat[-train,])
confusionMatrix(yhat, dat[-train,'y'])

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction  1  2
##          1 70  4
##          2  6 20
##                                          
##                Accuracy : 0.9            
##                  95% CI : (0.8238, 0.951)
##     No Information Rate : 0.76           
##     P-Value [Acc > NIR] : 0.0003075      
##                                          
##                   Kappa : 0.7335         
##                                          
##  Mcnemar's Test P-Value : 0.7518296      
##                                          
##             Sensitivity : 0.9211         
##             Specificity : 0.8333         
##          Pos Pred Value : 0.9459         
##          Neg Pred Value : 0.7692         
##              Prevalence : 0.7600         
##          Detection Rate : 0.7000         
##    Detection Prevalence : 0.7400         
##       Balanced Accuracy : 0.8772         
##                                          
##        'Positive' Class : 1              
##

Jika kita menaikkan nilai cost, maka kita akan menghasilkan kesalahan yang lebih kecil, namun hal tersebut juga berisiko overfitting.

svm.fit <- svm(y ~., dat[train,], kernel='radial', gamma=1, cost=1e5)

plot(svm.fit, dat[train,])

summary(svm.fit)

## 
## Call:
## svm(formula = y ~ ., data = dat[train, ], kernel = "radial", gamma = 1, 
##     cost = 1e+05)
## 
## 
## Parameters:
##    SVM-Type:  C-classification 
##  SVM-Kernel:  radial 
##        cost:  1e+05 
## 
## Number of Support Vectors:  22
## 
##  ( 11 11 )
## 
## 
## Number of Classes:  2 
## 
## Levels: 
##  1 2

Kita juga dapat melakukan validasi silang. Kita dapat menggunakan perintah tune() untuk mencoba beberapa nilai cost yang berbeda serta beberapa nilai gamma yang berbeda agar sesuai dengan batas nonlinear.

set.seed(100)
tune.out <- tune(svm, y ~., data=dat[train,], 
                 kernel='radial', 
                 ranges = list(cost=c(0.1,1,10,100,1000),
                 gamma=c(0.5, 1,2,3,4)))

summary(tune.out)

## 
## Parameter tuning of 'svm':
## 
## - sampling method: 10-fold cross validation 
## 
## - best parameters:
##  cost gamma
##    10   0.5
## 
## - best performance: 0.06 
## 
## - Detailed performance results:
##     cost gamma error dispersion
## 1  1e-01   0.5  0.26 0.08432740
## 2  1e+00   0.5  0.07 0.09486833
## 3  1e+01   0.5  0.06 0.08432740
## 4  1e+02   0.5  0.07 0.09486833
## 5  1e+03   0.5  0.06 0.08432740
## 6  1e-01   1.0  0.19 0.11005049
## 7  1e+00   1.0  0.06 0.08432740
## 8  1e+01   1.0  0.07 0.08232726
## 9  1e+02   1.0  0.08 0.09189366
## 10 1e+03   1.0  0.07 0.08232726
## 11 1e-01   2.0  0.20 0.11547005
## 12 1e+00   2.0  0.06 0.08432740
## 13 1e+01   2.0  0.08 0.09189366
## 14 1e+02   2.0  0.08 0.09189366
## 15 1e+03   2.0  0.12 0.10327956
## 16 1e-01   3.0  0.26 0.08432740
## 17 1e+00   3.0  0.06 0.08432740
## 18 1e+01   3.0  0.08 0.09189366
## 19 1e+02   3.0  0.10 0.08164966
## 20 1e+03   3.0  0.17 0.09486833
## 21 1e-01   4.0  0.28 0.07888106
## 22 1e+00   4.0  0.06 0.08432740
## 23 1e+01   4.0  0.08 0.09189366
## 24 1e+02   4.0  0.12 0.09189366
## 25 1e+03   4.0  0.18 0.10327956

# show best model
tune.out$best.model

## 
## Call:
## best.tune(METHOD = svm, train.x = y ~ ., data = dat[train, ], ranges = list(cost = c(0.1, 
##     1, 10, 100, 1000), gamma = c(0.5, 1, 2, 3, 4)), kernel = "radial")
## 
## 
## Parameters:
##    SVM-Type:  C-classification 
##  SVM-Kernel:  radial 
##        cost:  10 
## 
## Number of Support Vectors:  21

Model yang paling banyak mengurangi kesalahan pada data pelatihan adalah yang menggunakan cost = 10 dan gamma= 0.5. Kemudian kita akan lihat bagaimana performa dari model dalam memprediksi kelas dari 100 data uji.

yhat <- predict(tune.out$best.model, dat[-train,])
confusionMatrix(yhat, dat[-train, 'y'])

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction  1  2
##          1 69  3
##          2  7 21
##                                          
##                Accuracy : 0.9            
##                  95% CI : (0.8238, 0.951)
##     No Information Rate : 0.76           
##     P-Value [Acc > NIR] : 0.0003075      
##                                          
##                   Kappa : 0.7407         
##                                          
##  Mcnemar's Test P-Value : 0.3427817      
##                                          
##             Sensitivity : 0.9079         
##             Specificity : 0.8750         
##          Pos Pred Value : 0.9583         
##          Neg Pred Value : 0.7500         
##              Prevalence : 0.7600         
##          Detection Rate : 0.6900         
##    Detection Prevalence : 0.7200         
##       Balanced Accuracy : 0.8914         
##                                          
##        'Positive' Class : 1              
##

ROC CURVES

library(ROCR)

# function to handle the different models
rocplot <- function(pred, truth, ...){
  predob =  prediction(pred, truth)
  perf = performance(predob, 'tpr', 'fpr')
  plot(perf, ...)

}

Berikutnya kita akan membangun kembali SVM, kita tetapkan decision.values=TRUE untuk mendapatkan nilai yang sesuai.

svm.opt <- svm(y ~., data=dat[train,], kernel='radial',
               gamma=2, cost=1, decision.values=T)

fitted <- attributes(predict(svm.opt, dat[train,], decision.values=T))$decision.values

rocplot(fitted, dat[train,'y'], main='Training Data')

SVM dengan Package `caret`

library(ISLR)
library(caret)

attach(Auto)

## The following object is masked from package:ggplot2:
## 
##     mpg

str(Auto)

## 'data.frame':    392 obs. of  9 variables:
##  $ mpg         : num  18 15 18 16 17 15 14 14 14 15 ...
##  $ cylinders   : num  8 8 8 8 8 8 8 8 8 8 ...
##  $ displacement: num  307 350 318 304 302 429 454 440 455 390 ...
##  $ horsepower  : num  130 165 150 150 140 198 220 215 225 190 ...
##  $ weight      : num  3504 3693 3436 3433 3449 ...
##  $ acceleration: num  12 11.5 11 12 10.5 10 9 8.5 10 8.5 ...
##  $ year        : num  70 70 70 70 70 70 70 70 70 70 ...
##  $ origin      : num  1 1 1 1 1 1 1 1 1 1 ...
##  $ name        : Factor w/ 304 levels "amc ambassador brougham",..: 49 36 231 14 161 141 54 223 241 2 ...

head(Auto)

# Create a binary variable that takes on 1 for cars with gas mileage > median
Auto$y <- NA
Auto$y[Auto$mpg > median(Auto$mpg)] <- 1
Auto$y[Auto$mpg <= median(Auto$mpg)] <- 0
Auto$y <- as.factor(Auto$y)
length(Auto[is.na(Auto$y)]) # make sure there are no NA's

## [1] 0

SVM dengan Kernel Linear

set.seed(123)
split <- createDataPartition(y=Auto$y, p=0.7, list=FALSE)
train <- Auto[split,]
test <- Auto[-split,]
# Remove mpg / name features
train <- train[-c(1,9)]
test <- test[-c(1,9)]

# 10 fold cross validation
ctr <- trainControl(method='repeatedcv',
                    number=10,
                    repeats=3)

# Recall as C increases, the margin tends to get wider
grid <- data.frame(C=seq(0.01,10,0.5))

svm.linear <- train(y ~., train,
                 method='svmLinear',
                 preProc=c('center','scale'),
                 trControl=ctr,
                 tuneGrid=grid)
svm.linear

## Support Vector Machines with Linear Kernel 
## 
## 276 samples
##   7 predictor
##   2 classes: '0', '1' 
## 
## Pre-processing: centered (7), scaled (7) 
## Resampling: Cross-Validated (10 fold, repeated 3 times) 
## Summary of sample sizes: 248, 248, 248, 250, 248, 248, ... 
## Resampling results across tuning parameters:
## 
##   C     Accuracy   Kappa    
##   0.01  0.9055759  0.8111544
##   0.51  0.9009056  0.8018141
##   1.01  0.9009056  0.8018141
##   1.51  0.8996710  0.7993752
##   2.01  0.8984805  0.7969942
##   2.51  0.8949091  0.7898513
##   3.01  0.8936745  0.7873993
##   3.51  0.8936745  0.7873993
##   4.01  0.8936745  0.7873993
##   4.51  0.8901031  0.7802564
##   5.01  0.8912936  0.7826373
##   5.51  0.8901031  0.7802564
##   6.01  0.8888685  0.7778176
##   6.51  0.8876781  0.7754366
##   7.01  0.8888685  0.7778176
##   7.51  0.8888685  0.7778176
##   8.01  0.8888685  0.7778176
##   8.51  0.8888685  0.7778176
##   9.01  0.8888685  0.7778176
##   9.51  0.8888685  0.7778176
## 
## Accuracy was used to select the optimal model using the largest value.
## The final value used for the model was C = 0.01.

svm.linear$bestTune

ggplot(svm.linear)

# Training error rate
confusionMatrix(predict(svm.linear, train), train$y)

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction   0   1
##          0 120   7
##          1  18 131
##                                           
##                Accuracy : 0.9094          
##                  95% CI : (0.8692, 0.9405)
##     No Information Rate : 0.5             
##     P-Value [Acc > NIR] : <2e-16          
##                                           
##                   Kappa : 0.8188          
##                                           
##  Mcnemar's Test P-Value : 0.0455          
##                                           
##             Sensitivity : 0.8696          
##             Specificity : 0.9493          
##          Pos Pred Value : 0.9449          
##          Neg Pred Value : 0.8792          
##              Prevalence : 0.5000          
##          Detection Rate : 0.4348          
##    Detection Prevalence : 0.4601          
##       Balanced Accuracy : 0.9094          
##                                           
##        'Positive' Class : 0               
##

# Testing error rate
yhat <- predict(svm.linear, test)
confusionMatrix(yhat, test$y)

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction  0  1
##          0 50  2
##          1  8 56
##                                           
##                Accuracy : 0.9138          
##                  95% CI : (0.8472, 0.9579)
##     No Information Rate : 0.5             
##     P-Value [Acc > NIR] : <2e-16          
##                                           
##                   Kappa : 0.8276          
##                                           
##  Mcnemar's Test P-Value : 0.1138          
##                                           
##             Sensitivity : 0.8621          
##             Specificity : 0.9655          
##          Pos Pred Value : 0.9615          
##          Neg Pred Value : 0.8750          
##              Prevalence : 0.5000          
##          Detection Rate : 0.4310          
##    Detection Prevalence : 0.4483          
##       Balanced Accuracy : 0.9138          
##                                           
##        'Positive' Class : 0               
##

SVM dengan Kernel Polinomial

set.seed(123)
# Try a polynomial function
svm.poly <- train(y ~., train,
                 method='svmPoly',
                 trControl=ctr,
                 tuneLength=4)
                 
svm.poly

## Support Vector Machines with Polynomial Kernel 
## 
## 276 samples
##   7 predictor
##   2 classes: '0', '1' 
## 
## No pre-processing
## Resampling: Cross-Validated (10 fold, repeated 3 times) 
## Summary of sample sizes: 248, 248, 248, 249, 248, 249, ... 
## Resampling results across tuning parameters:
## 
##   degree  scale  C     Accuracy   Kappa    
##   1       0.001  0.25  0.6744132  0.3611722
##   1       0.001  0.50  0.7830552  0.5684360
##   1       0.001  1.00  0.8386142  0.6776049
##   1       0.001  2.00  0.8614944  0.7231179
##   1       0.010  0.25  0.8650217  0.7302161
##   1       0.010  0.50  0.8879494  0.7759434
##   1       0.010  1.00  0.9084113  0.8168315
##   1       0.010  2.00  0.9072209  0.8144100
##   1       0.100  0.25  0.9047517  0.8094241
##   1       0.100  0.50  0.9023267  0.8045640
##   1       0.100  1.00  0.9010921  0.8021251
##   1       0.100  2.00  0.9010921  0.8021251
##   1       1.000  0.25  0.9010921  0.8021251
##   1       1.000  0.50  0.9010921  0.8021251
##   1       1.000  1.00  0.8975207  0.7949822
##   1       1.000  2.00  0.8914326  0.7828098
##   2       0.001  0.25  0.7818647  0.5660551
##   2       0.001  0.50  0.8386142  0.6776049
##   2       0.001  1.00  0.8614944  0.7231179
##   2       0.001  2.00  0.8843339  0.7687422
##   2       0.010  0.25  0.8891840  0.7784227
##   2       0.010  0.50  0.9084113  0.8168315
##   2       0.010  1.00  0.9072209  0.8144100
##   2       0.010  2.00  0.9059422  0.8118052
##   2       0.100  0.25  0.9059422  0.8118052
##   2       0.100  0.50  0.9022826  0.8045060
##   2       0.100  1.00  0.9036053  0.8071692
##   2       0.100  2.00  0.8998542  0.7996593
##   2       1.000  0.25  0.9033374  0.8065509
##   2       1.000  0.50  0.9010039  0.8018328
##   2       1.000  1.00  0.9046635  0.8091448
##   2       1.000  2.00  0.9022385  0.8043653
##   3       0.001  0.25  0.7815120  0.5631297
##   3       0.001  0.50  0.8614503  0.7230732
##   3       0.001  1.00  0.8747219  0.7495509
##   3       0.001  2.00  0.8915649  0.7831846
##   3       0.010  0.25  0.9048840  0.8098271
##   3       0.010  0.50  0.9059863  0.8119577
##   3       0.010  1.00  0.9059422  0.8118052
##   3       0.010  2.00  0.9059422  0.8118052
##   3       0.100  0.25  0.9047517  0.8094243
##   3       0.100  0.50  0.9047517  0.8094243
##   3       0.100  1.00  0.9069970  0.8139451
##   3       0.100  2.00  0.9082350  0.8164230
##   3       1.000  0.25  0.9165276  0.8330726
##   3       1.000  0.50  0.9129562  0.8258502
##   3       1.000  1.00  0.9081502  0.8162956
##   3       1.000  2.00  0.8865893  0.7732103
## 
## Accuracy was used to select the optimal model using the largest value.
## The final values used for the model were degree = 3, scale = 1 and C = 0.25.

svm.poly$bestTune

plot(svm.poly)

# Training error rate
confusionMatrix(predict(svm.poly, train), train$y)

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction   0   1
##          0 134   4
##          1   4 134
##                                           
##                Accuracy : 0.971           
##                  95% CI : (0.9437, 0.9874)
##     No Information Rate : 0.5             
##     P-Value [Acc > NIR] : <2e-16          
##                                           
##                   Kappa : 0.942           
##                                           
##  Mcnemar's Test P-Value : 1               
##                                           
##             Sensitivity : 0.9710          
##             Specificity : 0.9710          
##          Pos Pred Value : 0.9710          
##          Neg Pred Value : 0.9710          
##              Prevalence : 0.5000          
##          Detection Rate : 0.4855          
##    Detection Prevalence : 0.5000          
##       Balanced Accuracy : 0.9710          
##                                           
##        'Positive' Class : 0               
##

# Testing error rate
yhat <- predict(svm.poly, test)
confusionMatrix(yhat, test$y)

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction  0  1
##          0 52  6
##          1  6 52
##                                           
##                Accuracy : 0.8966          
##                  95% CI : (0.8263, 0.9454)
##     No Information Rate : 0.5             
##     P-Value [Acc > NIR] : <2e-16          
##                                           
##                   Kappa : 0.7931          
##                                           
##  Mcnemar's Test P-Value : 1               
##                                           
##             Sensitivity : 0.8966          
##             Specificity : 0.8966          
##          Pos Pred Value : 0.8966          
##          Neg Pred Value : 0.8966          
##              Prevalence : 0.5000          
##          Detection Rate : 0.4483          
##    Detection Prevalence : 0.5000          
##       Balanced Accuracy : 0.8966          
##                                           
##        'Positive' Class : 0               
##

SVM dengan Kernel Radial

set.seed(123)
# Try a radial function
svm.radial <- train(y ~., train,
                 method='svmRadial',
                 trControl=ctr,
                 tuneLength=10)
svm.radial

## Support Vector Machines with Radial Basis Function Kernel 
## 
## 276 samples
##   7 predictor
##   2 classes: '0', '1' 
## 
## No pre-processing
## Resampling: Cross-Validated (10 fold, repeated 3 times) 
## Summary of sample sizes: 248, 248, 248, 249, 248, 249, ... 
## Resampling results across tuning parameters:
## 
##   C       Accuracy   Kappa    
##     0.25  0.9047517  0.8094511
##     0.50  0.9059422  0.8118321
##     1.00  0.9119387  0.8237946
##     2.00  0.9141874  0.8282886
##     4.00  0.9252578  0.8503684
##     8.00  0.9239350  0.8476921
##    16.00  0.9251696  0.8501577
##    32.00  0.9238027  0.8474235
##    64.00  0.9069156  0.8136933
##   128.00  0.8913512  0.7825718
## 
## Tuning parameter 'sigma' was held constant at a value of 0.2080168
## Accuracy was used to select the optimal model using the largest value.
## The final values used for the model were sigma = 0.2080168 and C = 4.

svm.radial$bestTune

plot(svm.radial)

# Training error rate
confusionMatrix(predict(svm.radial, train), train$y)

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction   0   1
##          0 132   4
##          1   6 134
##                                           
##                Accuracy : 0.9638          
##                  95% CI : (0.9344, 0.9825)
##     No Information Rate : 0.5             
##     P-Value [Acc > NIR] : <2e-16          
##                                           
##                   Kappa : 0.9275          
##                                           
##  Mcnemar's Test P-Value : 0.7518          
##                                           
##             Sensitivity : 0.9565          
##             Specificity : 0.9710          
##          Pos Pred Value : 0.9706          
##          Neg Pred Value : 0.9571          
##              Prevalence : 0.5000          
##          Detection Rate : 0.4783          
##    Detection Prevalence : 0.4928          
##       Balanced Accuracy : 0.9638          
##                                           
##        'Positive' Class : 0               
##

# Testing error rate
yhat <- predict(svm.radial, test)
confusionMatrix(yhat, test$y)

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction  0  1
##          0 52  5
##          1  6 53
##                                           
##                Accuracy : 0.9052          
##                  95% CI : (0.8367, 0.9517)
##     No Information Rate : 0.5             
##     P-Value [Acc > NIR] : <2e-16          
##                                           
##                   Kappa : 0.8103          
##                                           
##  Mcnemar's Test P-Value : 1               
##                                           
##             Sensitivity : 0.8966          
##             Specificity : 0.9138          
##          Pos Pred Value : 0.9123          
##          Neg Pred Value : 0.8983          
##              Prevalence : 0.5000          
##          Detection Rate : 0.4483          
##    Detection Prevalence : 0.4914          
##       Balanced Accuracy : 0.9052          
##                                           
##        'Positive' Class : 0               
##

Referensi

Folley, M. (Dec 5, 2022). Support Vector Machines. Retrieved from: https://bookdown.org/mpfoley1973/supervised-ml/support-vector-machines.html#support-vector-machines-1

Kelly, R. (July 14, 2012). Support Vector Machines. Retrieved from: https://rpubs.com/ryankelly/svm

Support Vector Machines. Retrieved from: http://uc-r.github.io/svm