Show Code
# Menginstal package yang diperlukan
install.packages(c(
"tidyverse",
"tidymodels",
"kknn",
"e1071",
"knitr"
))Dalam pembelajaran mesin terawasi (supervised learning), hubungan antara prediktor dan respons dapat dipelajari melalui pendekatan yang berbeda. Sebagian algoritma membentuk prediksi berdasarkan kedekatan suatu observasi dengan observasi lainnya, sedangkan algoritma lain membentuk fungsi keputusan melalui proses optimasi.
K-Nearest Neighbors (KNN) merupakan metode pembelajaran berbasis jarak (distance-based learning). Algoritma ini menggunakan sejumlah observasi data latih yang paling dekat dengan observasi baru untuk menentukan hasil prediksi. Sebaliknya, Support Vector Machine (SVM) menggunakan prinsip optimasi untuk membentuk fungsi keputusan berdasarkan karakteristik data latih.
Pada klasifikasi, SVM mencari batas keputusan yang memisahkan kelas dengan mempertimbangkan margin. Sementara itu, pengembangan SVM untuk respons numerik dikenal sebagai Support Vector Regression (SVR), yang membentuk fungsi regresi dengan toleransi kesalahan tertentu.
Perbedaan dasar kedua pendekatan dirangkum pada tabel berikut.
| Aspek | K-Nearest Neighbors | Support Vector Machine |
|---|---|---|
| Prinsip pembelajaran | Kedekatan antarobservasi | Optimasi fungsi keputusan |
| Dasar prediksi | Observasi terdekat | Fungsi keputusan hasil optimasi |
| Klasifikasi | Voting kelas tetangga | Penentuan kelas melalui batas keputusan |
| Regresi | Rata-rata respons tetangga | Fungsi regresi dengan toleransi kesalahan |
| Karakteristik model | Nonparametrik, berbasis observasi | Berbasis optimasi margin dan regularisasi |
| Parameter utama | Jumlah tetangga dan ukuran jarak | Cost, kernel, dan parameter kernel |
KNN dan SVM dapat digunakan pada klasifikasi maupun regresi, tetapi mempunyai formulasi dan mekanisme prediksi yang berbeda.
Misalkan tersedia \(n\) observasi dengan \(p\) prediktor yang dinyatakan sebagai:
\[\mathcal{D} = \left\{ (\mathbf{x}_i,y_i) \right\}_{i=1}^{n}\]
dengan:
Untuk klasifikasi, \(y_i\) menunjukkan kategori kelas. Sementara itu, pada regresi, \(y_i\) merupakan respons numerik.
Tujuan pemodelan adalah membentuk aturan prediksi untuk observasi baru \(\mathbf{x}_0\) berdasarkan hubungan yang dipelajari dari data latih.
K-Nearest Neighbors merupakan metode pembelajaran terawasi nonparametrik yang menggunakan kedekatan antarobservasi sebagai dasar prediksi. Algoritma ini tidak mengasumsikan bentuk hubungan tertentu antara prediktor dan respons, seperti hubungan linear atau kuadratik.
KNN bekerja dengan menghitung jarak antara observasi baru dan observasi pada data latih. Setelah seluruh jarak diperoleh, algoritma memilih \(K\) observasi dengan jarak terkecil. Respons dari observasi terdekat tersebut kemudian digunakan untuk menghasilkan prediksi.
Secara umum, proses KNN mencakup:
Referensi gambar: James et al. (2021), An Introduction to Statistical Learning, Figure 2.14.
Keterangan: Ilustrasi pemilihan tiga observasi terdekat untuk menentukan kelas observasi baru.
Perhatikan titik berbentuk silang hitam pada panel kiri.
Titik tersebut merupakan observasi baru yang belum diketahui kelasnya. Lingkaran menunjukkan wilayah yang memuat tiga observasi terdekat.
Di dalam lingkaran terdapat:
Dua observasi berwarna biru.
Satu observasi berwarna oranye.
Karena mayoritas tetangganya merupakan kelas biru, KNN menetapkan observasi baru tersebut ke kelas biru.
Panel kanan memperlihatkan batas keputusan yang dihasilkan ketika prosedur yang sama diterapkan pada berbagai kemungkinan posisi observasi baru.
Hal penting: Batas keputusan KNN terbentuk dari aturan pemilihan tetangga di berbagai posisi dalam ruang prediktor. Algoritma tidak terlebih dahulu mengestimasi satu persamaan garis pemisah seperti pada model klasifikasi linear.
Pemilihan tetangga merupakan komponen utama KNN. Oleh karena itu, ukuran jarak menentukan observasi mana yang dianggap paling dekat.
Jarak Euclidean antara observasi \(\mathbf{x}_i\) dan \(\mathbf{x}_j\) dinyatakan sebagai:
\[d(\mathbf{x}_i,\mathbf{x}_j) = \sqrt{ \sum_{r=1}^{p} (x_{ir}-x_{jr})^2 }\]
Untuk dua prediktor, formulasi tersebut menjadi:
\[d(\mathbf{x}_i,\mathbf{x}_j) = \sqrt{ (x_{i1}-x_{j1})^2+ (x_{i2}-x_{j2})^2 }\]
Sebagai contoh, misalkan:
\[\mathbf{x}_1=(2,3)\]
dan:
\[\mathbf{x}_2=(5,7)\]
Jarak kedua observasi adalah:
\[\begin{aligned} d(\mathbf{x}_1,\mathbf{x}_2) &= \sqrt{(2-5)^2+(3-7)^2}\\ &= \sqrt{9+16}\\ &=5 \end{aligned}\]
Semakin kecil nilai jarak, semakin dekat posisi kedua observasi dalam ruang prediktor.
Jarak Manhattan menghitung jumlah selisih absolut setiap prediktor:
\[d(\mathbf{x}_i,\mathbf{x}_j) = \sum_{r=1}^{p} |x_{ir}-x_{jr}|\]
Untuk contoh yang sama:
\[\begin{aligned} d(\mathbf{x}_1,\mathbf{x}_2) &= |2-5|+|3-7|\\ &=3+4\\ &=7 \end{aligned}\]
Euclidean Distance dan Manhattan Distance merupakan kasus khusus dari Minkowski Distance:
\[d_q(\mathbf{x}_i,\mathbf{x}_j) = \left( \sum_{r=1}^{p} |x_{ir}-x_{jr}|^q \right)^{1/q}\]
dengan \(q\geq1\).
Apabila \(q=1\), diperoleh Manhattan Distance. Apabila \(q=2\), diperoleh Euclidean Distance.
Perbedaan ukuran jarak dapat menghasilkan urutan tetangga yang berbeda sehingga turut memengaruhi hasil prediksi KNN.
Pada klasifikasi, KNN menggunakan kelas yang paling banyak ditemukan di antara \(K\) tetangga terdekat.
Misalkan \(\mathcal{N}_K(\mathbf{x}_0)\) merupakan himpunan indeks \(K\) observasi terdekat dari observasi baru \(\mathbf{x}_0\).
Proporsi tetangga yang termasuk kelas \(g\) dinyatakan sebagai:
\[\widehat{P}(Y=g\mid\mathbf{X}=\mathbf{x}_0) = \frac{1}{K} \sum_{i\in\mathcal{N}_K(\mathbf{x}_0)} I(y_i=g)\]
dengan fungsi indikator:
\[I(y_i=g) = \begin{cases} 1, & \text{jika } y_i=g\\ 0, & \text{jika } y_i\neq g \end{cases}\]
Kelas prediksi ditentukan berdasarkan proporsi terbesar:
\[\boxed{ \hat y_0 = \arg\max_g \widehat{P}(Y=g\mid\mathbf{X}=\mathbf{x}_0) }\]
Sebagai contoh, apabila digunakan \(K=5\) dengan tiga tetangga kelas A dan dua tetangga kelas B, maka:
\[\widehat P(Y=A\mid\mathbf{x}_0) = \frac{3}{5} = 0{,}6\]
\[\widehat P(Y=B\mid\mathbf{x}_0) = \frac{2}{5} = 0{,}4\]
Dengan demikian, observasi baru diklasifikasikan sebagai kelas A.
Proporsi tersebut merupakan perkiraan probabilitas kelas berdasarkan komposisi tetangga terpilih. Nilainya tidak otomatis menjadi probabilitas yang terkalibrasi.
Pada regresi, KNN menggunakan rata-rata nilai respons dari \(K\) tetangga terdekat.
Formulasinya adalah:
\[\boxed{ \hat y_0 = \frac{1}{K} \sum_{i\in\mathcal{N}_K(\mathbf{x}_0)} y_i }\]
Misalkan tiga observasi terdekat mempunyai nilai respons:
\[y_1=120,\qquad y_2=150,\qquad y_3=180\]
Dengan \(K=3\), prediksinya adalah:
\[\begin{aligned} \hat y_0 &= \frac{120+150+180}{3}\\ &=150 \end{aligned}\]
Perbedaan utama KNN klasifikasi dan regresi terletak pada cara menggabungkan respons tetangga. Klasifikasi menggunakan voting kelas, sedangkan regresi menggunakan rata-rata respons numerik.
Pada KNN standar, setiap tetangga memberikan kontribusi yang sama. Akan tetapi, observasi yang lebih dekat dapat diberikan bobot lebih besar.
Untuk regresi, prediksi berbobot dinyatakan sebagai:
\[\hat y_0 = \frac{ \sum_{i\in\mathcal{N}_K(\mathbf{x}_0)} w_i(\mathbf{x}_0)y_i }{ \sum_{i\in\mathcal{N}_K(\mathbf{x}_0)} w_i(\mathbf{x}_0) }\]
dengan \(w_i(\mathbf{x}_0)\geq0\) merupakan bobot tetangga ke-\(i\).
Pada klasifikasi berbobot, kontribusi kelas dihitung berdasarkan jumlah bobot:
\[\hat y_0 = \arg\max_g \sum_{i\in\mathcal{N}_K(\mathbf{x}_0)} w_i(\mathbf{x}_0)I(y_i=g)\]
Pembobotan memungkinkan observasi yang lebih dekat mempunyai kontribusi lebih besar terhadap hasil prediksi.
Jumlah tetangga \(K\) menentukan tingkat fleksibilitas model KNN.
Referensi gambar: James et al. (2021), An Introduction to Statistical Learning, Figure 2.16.
Keterangan: Perbandingan fleksibilitas batas keputusan KNN berdasarkan jumlah tetangga.
Pada panel kiri, \(K=1\) menghasilkan batas keputusan yang sangat tidak beraturan. Setiap prediksi bergantung pada satu observasi terdekat, sehingga perubahan kecil posisi observasi baru dapat mengubah kelas prediksi.
Pada panel kanan, \(K=100\) menghasilkan batas yang lebih sederhana. Prediksi dipengaruhi oleh lebih banyak observasi, sehingga pola lokal yang lebih kecil dapat terabaikan.
Nilai \(K\) yang kecil menghasilkan model lebih fleksibel karena prediksi sangat dipengaruhi observasi lokal. Namun, kondisi ini juga meningkatkan sensitivitas model terhadap variasi data.
Sebaliknya, nilai \(K\) yang besar menghasilkan prediksi lebih halus karena mempertimbangkan lebih banyak observasi.
Secara umum:
Hubungan tersebut menunjukkan adanya pertukaran antara bias dan varians (bias-variance trade-off).
Referensi gambar: James et al. (2021), An Introduction to Statistical Learning, Figure 2.17.
Keterangan: Hubungan fleksibilitas KNN dengan kesalahan prediksi pada data latih dan data uji.
Pada gambar 2.17, sumbu horizontal menggunakan \(1/k\), sehingga bergerak ke kanan berarti jumlah tetangga semakin kecil dan model semakin fleksibel.
Perhatikan bahwa kesalahan pada data latih cenderung turun ketika fleksibilitas meningkat. Namun, kesalahan pada data uji tidak selalu mengikuti pola tersebut.Ketika model terlalu fleksibel, kesalahan pada data latih dapat menjadi kecil, tetapi kemampuan prediksi pada observasi baru belum tentu meningkat. Kondisi tersebut berkaitan dengan risiko overfitting.
Pelajaran utamanya: nilai \(k\) tidak ditentukan berdasarkan kemampuan model menyesuaikan data latih semata. Nilai tersebut perlu dipilih menggunakan prosedur validasi.
Ada empat persoalan penting.
Pertama, curse of dimensionality. Ketika jumlah dimensi meningkat, observasi cenderung semakin tersebar dalam ruang prediktor. Tetangga yang secara relatif paling dekat belum tentu benar-benar dekat secara geometris.
Kedua, sensitivitas terhadap skala. Prediktor dengan rentang nilai besar dapat mendominasi jarak.
Ketiga, sensitivitas terhadap distribusi kelas. Dalam klasifikasi dengan kelas tidak seimbang, kelas mayoritas berpotensi lebih sering muncul di lingkungan tetangga.
Keempat, biaya prediksi. KNN perlu mencari tetangga untuk setiap observasi baru. Untuk data besar, pencarian tersebut dapat memerlukan komputasi yang cukup tinggi, meskipun tersedia berbagai strategi pencarian yang lebih efisien.
Support Vector Machine merupakan metode pembelajaran terawasi yang mencari fungsi keputusan melalui proses optimasi.
Pada klasifikasi biner, SVM berusaha membentuk hyperplane yang memisahkan dua kelas dengan margin sebesar mungkin. Margin merupakan jarak antara hyperplane dan observasi terdekat yang menentukan batas pemisahan.
Observasi yang berperan dalam menentukan margin disebut support vectors.
Referensi gambar: James et al. (2021), An Introduction to Statistical Learning, Figure 9.3.
Keterangan: Hyperplane optimal, batas margin, dan observasi yang berperan sebagai support vectors.
Pada gambar tersebut:
Garis penuh merupakan hyperplane pemisah.
Dua garis putus-putus merupakan batas margin.
Titik yang berada tepat pada batas margin merupakan support vectors.
Wilayah dengan warna berbeda menunjukkan kelas yang diprediksi oleh model.
Support vectors memiliki peranan penting karena menentukan posisi batas keputusan yang optimal. Pada kasus margin maksimum, perubahan posisi support vectors dapat mengubah hyperplane, sedangkan perubahan kecil pada observasi lain yang tetap berada di luar margin tidak selalu memengaruhinya.
Untuk \(p\) prediktor, fungsi keputusan linear dinyatakan sebagai:
\[f(\mathbf{x}) = \mathbf{w}^{\top}\mathbf{x}+b\]
dengan:
Hyperplane pemisah dinyatakan sebagai:
\[\boxed{ \mathbf{w}^{\top}\mathbf{x}+b=0 }\]
Untuk dua prediktor, persamaan tersebut menjadi:
\[w_1x_1+w_2x_2+b=0\]
Pada klasifikasi biner, kelas respons direpresentasikan sebagai:
\[y_i\in\{-1,+1\}\]
Aturan prediksi dinyatakan sebagai:
\[\boxed{ \hat y = \operatorname{sign} \left( \mathbf{w}^{\top}\mathbf{x}+b \right) }\]
Nilai fungsi keputusan positif menghasilkan kelas \(+1\), sedangkan nilai negatif menghasilkan kelas \(-1\).
Hard-margin SVM digunakan pada kondisi ketika kedua kelas dapat dipisahkan secara linear tanpa kesalahan.
Batas margin kanonik dinyatakan sebagai:
\[\mathbf{w}^{\top}\mathbf{x}+b=1\]
dan:
\[\mathbf{w}^{\top}\mathbf{x}+b=-1\]
Jarak antara kedua batas tersebut adalah:
\[M = \frac{2}{\|\mathbf{w}\|}\]
dengan:
\[\|\mathbf{w}\| = \sqrt{ \sum_{j=1}^{p}w_j^2 }\]
Memaksimumkan margin ekuivalen dengan meminimumkan norma kuadrat vektor bobot.
Formulasi optimasi hard-margin SVM adalah:
\[\boxed{ \min_{\mathbf{w},b} \frac{1}{2}\|\mathbf{w}\|^2 }\]
dengan kendala:
\[y_i \left( \mathbf{w}^{\top}\mathbf{x}_i+b \right) \geq1, \qquad i=1,\ldots,n\]
Kendala tersebut memastikan setiap observasi berada pada sisi hyperplane yang sesuai dengan kelasnya dan tidak melanggar batas margin.
Dalam data empiris, kelas sering kali tumpang tindih sehingga tidak seluruh observasi dapat dipisahkan secara sempurna.
Soft-margin SVM memperkenalkan variabel slack \(\xi_i\) untuk memberikan toleransi terhadap pelanggaran margin.
Fungsi optimasinya menjadi:
\[\boxed{ \min_{\mathbf{w},b,\boldsymbol{\xi}} \left[ \frac{1}{2}\|\mathbf{w}\|^2 + C\sum_{i=1}^{n}\xi_i \right] }\]
dengan kendala:
\[y_i \left( \mathbf{w}^{\top}\mathbf{x}_i+b \right) \geq1-\xi_i\]
\[\xi_i\geq0\]
Parameter \(C>0\) mengatur penalti terhadap pelanggaran margin.
Dengan demikian, pemilihan \(C\) memengaruhi keseimbangan antara kompleksitas fungsi keputusan dan kesalahan klasifikasi.
Hyperplane linear tidak selalu mampu merepresentasikan pemisahan kelas yang mempunyai pola nonlinear.
SVM dapat menggunakan fungsi kernel untuk membentuk batas keputusan nonlinear. Secara konseptual, prediktor dipetakan ke ruang fitur melalui fungsi \(\phi(\cdot)\).
Kernel menyatakan hasil perkalian dalam ruang fitur tersebut:
\[K(\mathbf{x}_i,\mathbf{x}_j) = \phi(\mathbf{x}_i)^\top \phi(\mathbf{x}_j)\]
Pendekatan ini memungkinkan perhitungan hubungan antarobservasi dalam ruang fitur tanpa harus membentuk seluruh koordinat hasil pemetaan secara eksplisit.
Beberapa kernel yang umum digunakan adalah:
\[K(\mathbf{x}_i,\mathbf{x}_j) = \mathbf{x}_i^\top\mathbf{x}_j\]
\[K(\mathbf{x}_i,\mathbf{x}_j) = \left( \gamma\mathbf{x}_i^\top\mathbf{x}_j+r \right)^d\]
\[K(\mathbf{x}_i,\mathbf{x}_j) = \exp \left( -\gamma \|\mathbf{x}_i-\mathbf{x}_j\|^2 \right)\]
dengan \(\gamma>0\) mengendalikan karakteristik kernel RBF.
Untuk SVM berbasis kernel, fungsi keputusan klasifikasi biner dapat ditulis sebagai:
\[f(\mathbf{x}) = \sum_{i\in SV} \alpha_i y_i K(\mathbf{x}_i,\mathbf{x}) +b\]
dengan \(SV\) menyatakan himpunan indeks support vectors dan \(\alpha_i\) merupakan koefisien dual yang tidak nol pada support vectors.
Prediksi kelas diperoleh melalui:
\[\hat y = \operatorname{sign} \left( f(\mathbf{x}) \right)\]
Dengan demikian, kernel memungkinkan pembentukan batas keputusan nonlinear, sedangkan prinsip pemilihan fungsi keputusan tetap didasarkan pada optimasi margin.
Formulasi dasar SVM merupakan klasifikasi biner. Untuk respons dengan lebih dari dua kelas, beberapa pengklasifikasi biner dapat digabungkan menggunakan strategi seperti one-versus-one atau one-versus-rest.
Support Vector Regression merupakan pengembangan prinsip support vector untuk respons numerik.
Berbeda dari SVM klasifikasi yang membentuk batas pemisah antarkelas, SVR mencari fungsi regresi dengan mengendalikan kompleksitas model dan kesalahan prediksi.
Pada SVR, diperkenalkan parameter \(\varepsilon\) yang menentukan wilayah toleransi di sekitar fungsi regresi.
Misalkan fungsi regresi linear dinyatakan sebagai:
\[f(\mathbf{x}) = \mathbf{w}^{\top}\mathbf{x}+b\]
Wilayah toleransi dibentuk berdasarkan:
\[f(\mathbf{x})-\varepsilon \leq y \leq f(\mathbf{x})+\varepsilon\]
Wilayah tersebut dikenal sebagai epsilon-insensitive tube atau \(\varepsilon\)-tube.
Referensi gambar: Smola dan Schölkopf (2004), A Tutorial on Support Vector Regression, Figure 1.
Keterangan: Wilayah toleransi di sekitar fungsi regresi dan observasi yang berada di dalam maupun di luar epsilon-tube.
Dalam ilustrasi tersebut, fungsi regresi berada di tengah suatu daerah toleransi yang dibatasi oleh:
\[f(\mathbf{x}) + \varepsilon\]
dan
\[f(\mathbf{x}) - \varepsilon\]
Observasi yang berada di dalam atau tepat pada batas tube tidak dikenai penalti berdasarkan fungsi epsilon-insensitive loss. Sebaliknya, observasi yang berada di luar tube menghasilkan penalti sesuai besarnya pelanggaran.
Fungsi kerugian SVR dinyatakan sebagai:
\[\boxed{ L_{\varepsilon} \left( y_i,f(\mathbf{x}_i) \right) = \max \left( 0, |y_i-f(\mathbf{x}_i)|-\varepsilon \right) }\]
Misalkan nilai prediksi adalah 100 dengan parameter \(\varepsilon=5\).
| Nilai aktual | Kesalahan absolut | Epsilon-insensitive loss |
|---|---|---|
| 102 | 2 | 0 |
| 105 | 5 | 0 |
| 108 | 8 | 3 |
| 112 | 12 | 7 |
Contoh tersebut memperlihatkan bahwa SVR tidak memberikan penalti terhadap seluruh kesalahan prediksi. Penalti baru muncul ketika kesalahan absolut melebihi nilai \(\varepsilon\).
Untuk mengakomodasi observasi yang berada di luar epsilon-tube, digunakan variabel slack \(\xi_i\) dan \(\xi_i^*\).
Fungsi optimasi epsilon-SVR dinyatakan sebagai:
\[\boxed{ \min_{ \mathbf{w},b, \boldsymbol{\xi}, \boldsymbol{\xi}^{*} } \left[ \frac{1}{2}\|\mathbf{w}\|^2 + C\sum_{i=1}^{n} (\xi_i+\xi_i^*) \right] }\]
dengan kendala:
\[y_i-f(\mathbf{x}_i) \leq \varepsilon+\xi_i\]
\[f(\mathbf{x}_i)-y_i \leq \varepsilon+\xi_i^*\]
\[\xi_i,\xi_i^*\geq0\]
Pada formulasi tersebut:
Observasi yang berada di luar tube dapat berperan sebagai support vectors. Observasi pada batas tube juga dapat menjadi support vectors, sedangkan observasi yang berada secara ketat di dalam tube umumnya tidak mempunyai kontribusi koefisien dual terhadap fungsi prediksi.
SVR dapat menggunakan fungsi kernel untuk membentuk hubungan nonlinear.
Fungsi prediksinya dinyatakan sebagai:
\[\boxed{ f(\mathbf{x}) = \sum_{i\in SV} (\alpha_i-\alpha_i^*) K(\mathbf{x}_i,\mathbf{x}) +b }\]
dengan \(\alpha_i\) dan \(\alpha_i^*\) merupakan koefisien dual dari formulasi optimasi SVR.
Kernel yang digunakan dapat berupa linear, polynomial, maupun RBF.
Dengan demikian, SVM klasifikasi dan SVR memiliki dasar optimasi dan penggunaan kernel yang berkaitan, tetapi berbeda dalam bentuk fungsi kerugian dan tujuan prediksinya.
KNN dan SVM dapat dipengaruhi oleh skala prediktor.
Pada KNN, ukuran jarak ditentukan oleh selisih nilai setiap prediktor. Prediktor dengan rentang yang lebih besar dapat memberikan kontribusi dominan terhadap jarak Euclidean.
Pada SVM, perbedaan skala memengaruhi geometri ruang fitur, optimasi margin, serta hasil perhitungan kernel tertentu.
Standardisasi merupakan salah satu pendekatan untuk menyesuaikan skala prediktor:
\[z_{ij} = \frac{x_{ij}-\bar{x}_j}{s_j}\]
dengan \(\bar{x}_j\) dan \(s_j\) masing-masing merupakan rata-rata serta simpangan baku prediktor ke-\(j\) yang dihitung dari data latih.
KNN dan SVM umumnya memerlukan representasi numerik untuk menghitung jarak atau fungsi kernel.
Prediktor kategorik nominal dapat direpresentasikan melalui pengodean indikator, misalnya:
\[D_k = I(X=c_k)\]
dengan \(c_k\) merupakan kategori ke-\(k\).
Namun, pengodean kategorik juga memengaruhi representasi geometris data. Pada KNN, perubahan pengodean dapat mengubah jarak antarobservasi. Pada SVM, perubahan tersebut dapat memengaruhi bentuk fungsi keputusan.
Oleh karena itu, representasi prediktor perlu disesuaikan dengan karakteristik data dan prinsip algoritma.
Pada metode berbasis jarak, peningkatan jumlah prediktor dapat menyebabkan observasi menjadi relatif berjauhan dalam ruang fitur.
Kondisi ini dikenal sebagai curse of dimensionality.
Ketika jumlah prediktor meningkat, perbedaan antara jarak observasi terdekat dan terjauh dapat menjadi kurang informatif. Akibatnya, konsep kedekatan lokal yang digunakan KNN dapat kehilangan sebagian kegunaannya.
Pada SVM, penambahan fitur juga dapat memengaruhi kompleksitas model, meskipun pengaruhnya bergantung pada kernel dan regularisasi yang digunakan.
Seluruh transformasi yang memerlukan estimasi parameter harus didasarkan pada data latih. Informasi dari data uji tidak boleh digunakan untuk menentukan parameter transformasi maupun membentuk model.
Prinsip tersebut diperlukan agar evaluasi prediksi mencerminkan kemampuan model pada observasi yang tidak digunakan dalam proses pembelajaran.
KNN dan SVM merupakan dua pendekatan pembelajaran terawasi dengan mekanisme berbeda.
KNN menggunakan informasi lokal berdasarkan jarak antarobservasi. Pada klasifikasi, prediksi diperoleh melalui voting kelas tetangga, sedangkan pada regresi digunakan rata-rata respons tetangga.
SVM membentuk fungsi keputusan berdasarkan prinsip optimasi. Untuk klasifikasi, proses tersebut berkaitan dengan pemisahan kelas dan margin. Untuk regresi, SVR menggunakan wilayah toleransi epsilon untuk menentukan penalti kesalahan prediksi.
| Metode | Jenis Respons | Prinsip Prediksi | Parameter Utama |
|---|---|---|---|
| KNN Classification | Kategorik | Voting kelas tetangga terdekat | \(K\), jarak, bobot |
| KNN Regression | Numerik | Rata-rata respons tetangga terdekat | \(K\), jarak, bobot |
| Support Vector Classification | Kategorik | Fungsi keputusan berdasarkan margin | \(C\), kernel, parameter kernel |
| Support Vector Regression | Numerik | Fungsi regresi dengan epsilon-insensitive loss | \(C\), \(\varepsilon\), kernel, parameter kernel |
Perbedaan prinsip kerja tersebut menyebabkan pemilihan metode perlu mempertimbangkan tipe respons, karakteristik prediktor, bentuk hubungan yang ingin dipelajari, dan kompleksitas model.
Praktikum ini menggunakan beberapa package R untuk pengolahan data, penerapan algoritma K-Nearest Neighbors (KNN) dan Support Vector Machine (SVM), serta evaluasi hasil prediksi. Package yang digunakan dipilih berdasarkan kebutuhan masing-masing tahap analisis, mulai dari penyiapan data hingga pemeriksaan kinerja model.
| Package | Fungsi dalam Praktikum | Fungsi R yang Digunakan |
|---|---|---|
tidyverse |
Mengolah data, memilih dan mengubah peubah, menyusun ringkasan, serta membuat visualisasi data dan hasil pemodelan. | select(), mutate(), filter(), ggplot(), geom_point(), geom_line() |
tidymodels |
Membagi data latih dan data uji, menyiapkan prediktor, melakukan standardisasi, serta mengevaluasi hasil klasifikasi dan regresi. | initial_split(), training(), testing(), recipe(), step_normalize(), accuracy(), roc_auc(), rmse(), mae() |
kknn |
Menerapkan algoritma KNN untuk klasifikasi dan regresi. Package ini memungkinkan pengaturan jumlah tetangga, ukuran jarak, dan pembobotan tetangga. | kknn(), predict() |
e1071 |
Menerapkan SVM untuk klasifikasi dan Support Vector Regression (SVR) untuk regresi, termasuk penggunaan kernel linear, polynomial, dan radial. | svm(), predict() |
knitr |
Menampilkan hasil analisis dalam bentuk tabel yang rapi pada dokumen Quarto. | kable() |
Package tidymodels merupakan kumpulan package untuk pemodelan statistika dan machine learning. Di dalamnya sudah tersedia beberapa package yang digunakan dalam praktikum, antara lain:
rsample untuk pembagian data dan resampling.recipes untuk penyiapan dan transformasi prediktor.yardstick untuk perhitungan metrik evaluasi.parsnip untuk penyusunan spesifikasi model.workflows untuk menggabungkan tahapan preprocessing dan pemodelan.Oleh karena itu, package tersebut tidak perlu dipasang secara terpisah apabila tidymodels sudah berhasil diinstal.
Instalasi package hanya perlu dilakukan satu kali pada komputer yang digunakan. Jika package sudah tersedia, tahap instalasi dapat dilewati.
# Menginstal package yang diperlukan
install.packages(c(
"tidyverse",
"tidymodels",
"kknn",
"e1071",
"knitr"
))Kode instalasi di atas tidak dijalankan secara otomatis ketika dokumen Quarto dirender. Jika diperlukan, jalankan perintah instalasi secara langsung melalui Console R.
Setelah instalasi selesai, package dipanggil menggunakan fungsi library() agar fungsi-fungsi yang diperlukan tersedia selama praktikum.
# Package untuk pengolahan dan visualisasi data
library(tidyverse)── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
✔ dplyr 1.2.1 ✔ readr 2.2.0
✔ forcats 1.0.1 ✔ stringr 1.6.0
✔ ggplot2 4.0.3 ✔ tibble 3.3.1
✔ lubridate 1.9.5 ✔ tidyr 1.3.2
✔ purrr 1.2.2
── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
✖ dplyr::filter() masks stats::filter()
✖ dplyr::lag() masks stats::lag()
ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors
# Package untuk penyiapan data dan evaluasi model
library(tidymodels)── Attaching packages ────────────────────────────────────── tidymodels 1.5.0 ──
✔ broom 1.0.13 ✔ rsample 1.3.2
✔ dials 1.4.4 ✔ tailor 0.1.0
✔ infer 1.1.0 ✔ tune 2.1.0
✔ modeldata 1.6.0 ✔ workflows 1.3.0
✔ parsnip 1.6.1 ✔ workflowsets 1.1.1
✔ recipes 1.4.0 ✔ yardstick 1.4.0
── Conflicts ───────────────────────────────────────── tidymodels_conflicts() ──
✖ scales::discard() masks purrr::discard()
✖ dplyr::filter() masks stats::filter()
✖ recipes::fixed() masks stringr::fixed()
✖ dplyr::lag() masks stats::lag()
✖ yardstick::spec() masks readr::spec()
✖ recipes::step() masks stats::step()
# Package untuk pemodelan KNN
library(kknn)
# Package untuk pemodelan SVM dan SVR
library(e1071)
Attaching package: 'e1071'
The following object is masked from 'package:tune':
tune
The following object is masked from 'package:rsample':
permutations
The following object is masked from 'package:parsnip':
tune
The following object is masked from 'package:ggplot2':
element
# Package untuk penyajian tabel
library(knitr)Penggunaan package disesuaikan dengan metode yang diterapkan. KNN dan SVM dapat digunakan untuk klasifikasi maupun regresi, tetapi bentuk respons dan hasil prediksi yang dihasilkan berbeda.
| Metode | Jenis Pemodelan | Package | Fungsi Utama | Bentuk Prediksi |
|---|---|---|---|---|
| KNN Classification | Klasifikasi | kknn |
kknn() |
Kategori kelas |
| KNN Regression | Regresi | kknn |
kknn() |
Nilai numerik |
| Support Vector Classification | Klasifikasi | e1071 |
svm() |
Kategori kelas |
| Support Vector Regression | Regresi | e1071 |
svm() |
Nilai numerik |
Pada KNN, penentuan kelas atau nilai prediksi didasarkan pada observasi data latih yang memiliki jarak paling dekat dengan observasi baru.
Sementara itu, SVM untuk klasifikasi membentuk batas keputusan berdasarkan prinsip margin maksimum, sedangkan SVR menggunakan fungsi kerugian yang memberikan toleransi terhadap selisih tertentu antara nilai aktual dan prediksi.
Meskipun kedua jenis pemodelan SVM dapat dijalankan menggunakan fungsi svm(), formulasi optimasi klasifikasi dan regresi tidak sama. Perbedaan tersebut akan dijelaskan pada pembahasan masing-masing metode.
Seluruh proses preprocessing yang memerlukan estimasi parameter, seperti standardisasi menggunakan rata-rata dan simpangan baku, dilakukan berdasarkan data latih. Parameter yang diperoleh kemudian diterapkan pada data uji. # H. Implementasi KNN dan SVM
Data yang digunakan pada praktikum ini adalah Wine Quality, yang memuat karakteristik fisikokimia dan hasil penilaian kualitas anggur Vinho Verde dari Portugal. Dataset ini diperkenalkan oleh Cortez et al. (2009) untuk mempelajari hubungan antara karakteristik fisikokimia anggur dan penilaian kualitas berdasarkan evaluasi sensorik.
Data terdiri atas dua jenis anggur, yaitu anggur merah (red wine) dan anggur putih (white wine). Pengukuran fisikokimia digunakan sebagai variabel prediktor, sedangkan skor kualitas (quality) digunakan sebagai variabel respons. Karakteristik tersebut memungkinkan data dipelajari melalui pendekatan klasifikasi maupun regresi.
Sumber data: UCI Machine Learning Repository – Wine Quality.
Sebelum melakukan pemodelan, struktur data perlu diperiksa untuk mengetahui jumlah observasi, banyaknya variabel, tipe data, dan bentuk nilai yang tersimpan pada setiap kolom.
Pemeriksaan awal dilakukan dengan membaca berkas CSV dan menampilkan beberapa observasi pertama.
# Membaca data
wine_data <- read_csv("wine-quality-white-and-red.csv",
show_col_types = FALSE)
# Menampilkan enam observasi pertama
head(wine_data)Selanjutnya, dimensi, nama variabel, dan struktur data diperiksa menggunakan fungsi dim(), names(), dan glimpse().
# Memeriksa dimensi data
dim(wine_data)[1] 6497 13
# Menampilkan nama variabel
names(wine_data) [1] "type" "fixed acidity" "volatile acidity"
[4] "citric acid" "residual sugar" "chlorides"
[7] "free sulfur dioxide" "total sulfur dioxide" "density"
[10] "pH" "sulphates" "alcohol"
[13] "quality"
# Memeriksa struktur data
glimpse(wine_data)Rows: 6,497
Columns: 13
$ type <chr> "white", "white", "white", "white", "white", "w…
$ `fixed acidity` <dbl> 7.0, 6.3, 8.1, 7.2, 7.2, 8.1, 6.2, 7.0, 6.3, 8.…
$ `volatile acidity` <dbl> 0.27, 0.30, 0.28, 0.23, 0.23, 0.28, 0.32, 0.27,…
$ `citric acid` <dbl> 0.36, 0.34, 0.40, 0.32, 0.32, 0.40, 0.16, 0.36,…
$ `residual sugar` <dbl> 20.70, 1.60, 6.90, 8.50, 8.50, 6.90, 7.00, 20.7…
$ chlorides <dbl> 0.045, 0.049, 0.050, 0.058, 0.058, 0.050, 0.045…
$ `free sulfur dioxide` <dbl> 45, 14, 30, 47, 47, 30, 30, 45, 14, 28, 11, 17,…
$ `total sulfur dioxide` <dbl> 170, 132, 97, 186, 186, 97, 136, 170, 132, 129,…
$ density <dbl> 1.0010, 0.9940, 0.9951, 0.9956, 0.9956, 0.9951,…
$ pH <dbl> 3.00, 3.30, 3.26, 3.19, 3.19, 3.26, 3.18, 3.00,…
$ sulphates <dbl> 0.45, 0.49, 0.44, 0.40, 0.40, 0.44, 0.47, 0.45,…
$ alcohol <dbl> 8.8, 9.5, 10.1, 9.9, 9.9, 10.1, 9.6, 8.8, 9.5, …
$ quality <dbl> 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 7, 5, 7,…
Fungsi dim() memberikan informasi mengenai jumlah baris dan kolom, sedangkan names() menampilkan nama seluruh variabel. Fungsi glimpse() digunakan untuk melihat tipe data dan contoh nilai pada setiap variabel sehingga dapat diketahui variabel yang bersifat numerik maupun kategorik.
Berdasarkan pemeriksaan struktur data, diperoleh 6.497 observasi dengan 13 variabel. Variabel type tersimpan sebagai data karakter (chr) yang menunjukkan jenis anggur, sedangkan sebelas variabel fisikokimia tersimpan sebagai data numerik (dbl). Variabel quality juga terbaca sebagai numerik, tetapi nilainya merupakan skor penilaian kualitas yang memiliki urutan tertentu sehingga secara konseptual bersifat ordinal.
Beberapa nama variabel masih menggunakan spasi, seperti fixed acidity, volatile acidity, dan residual sugar. Penamaan tersebut perlu diperhatikan ketika variabel dipanggil dalam sintaks R. Penyesuaian nama variabel akan dilakukan pada tahap persiapan data agar lebih mudah digunakan selama pemodelan.
Statistik deskriptif digunakan untuk memberikan gambaran awal mengenai karakteristik prediktor numerik. Pemeriksaan dilakukan terhadap nilai minimum, kuartil pertama, median, rata-rata, simpangan baku, kuartil ketiga, dan nilai maksimum.
Ukuran pemusatan dan penyebaran tersebut dapat membantu mengidentifikasi perbedaan rentang nilai antarvariabel serta melihat indikasi distribusi yang tidak simetris. Informasi ini diperlukan karena representasi dan skala prediktor dapat memengaruhi proses pemodelan KNN dan SVM.
Statistik deskriptif dihitung untuk sebelas variabel fisikokimia, sedangkan variabel quality akan diperiksa secara terpisah melalui distribusi skor kualitas.
# Statistik deskriptif prediktor numerik
ringkasan_numerik <- wine_data %>%
select(-type, -quality) %>%
pivot_longer(
cols = everything(),
names_to = "variabel",
values_to = "nilai"
) %>%
group_by(variabel) %>%
summarise(
minimum = min(nilai, na.rm = TRUE),
kuartil_1 = quantile(nilai, 0.25, na.rm = TRUE),
median = median(nilai, na.rm = TRUE),
rata_rata = mean(nilai, na.rm = TRUE),
simpangan_baku = sd(nilai, na.rm = TRUE),
kuartil_3 = quantile(nilai, 0.75, na.rm = TRUE),
maksimum = max(nilai, na.rm = TRUE),
.groups = "drop"
)
knitr::kable(
ringkasan_numerik,
digits = 4,
caption = "Statistik deskriptif variabel fisikokimia"
)| variabel | minimum | kuartil_1 | median | rata_rata | simpangan_baku | kuartil_3 | maksimum |
|---|---|---|---|---|---|---|---|
| alcohol | 8.0000 | 9.5000 | 10.3000 | 10.4918 | 1.1927 | 11.300 | 14.900 |
| chlorides | 0.0090 | 0.0380 | 0.0470 | 0.0560 | 0.0350 | 0.065 | 0.611 |
| citric acid | 0.0000 | 0.2500 | 0.3100 | 0.3186 | 0.1453 | 0.390 | 1.660 |
| density | 0.9871 | 0.9923 | 0.9949 | 0.9947 | 0.0030 | 0.997 | 1.039 |
| fixed acidity | 3.8000 | 6.4000 | 7.0000 | 7.2153 | 1.2964 | 7.700 | 15.900 |
| free sulfur dioxide | 1.0000 | 17.0000 | 29.0000 | 30.5253 | 17.7494 | 41.000 | 289.000 |
| pH | 2.7200 | 3.1100 | 3.2100 | 3.2185 | 0.1608 | 3.320 | 4.010 |
| residual sugar | 0.6000 | 1.8000 | 3.0000 | 5.4432 | 4.7578 | 8.100 | 65.800 |
| sulphates | 0.2200 | 0.4300 | 0.5100 | 0.5313 | 0.1488 | 0.600 | 2.000 |
| total sulfur dioxide | 6.0000 | 77.0000 | 118.0000 | 115.7446 | 56.5219 | 156.000 | 440.000 |
| volatile acidity | 0.0800 | 0.2300 | 0.2900 | 0.3397 | 0.1646 | 0.400 | 1.580 |
Statistik deskriptif menunjukkan adanya perbedaan skala yang cukup besar antarvariabel fisikokimia. Sebagai contoh, total sulfur dioxide memiliki rentang 6–440, sedangkan density hanya berkisar antara 0,9871–1,0390. Perbedaan ini perlu diperhatikan karena prediktor dengan skala lebih besar dapat mendominasi perhitungan jarak pada KNN maupun kernel berbasis jarak pada SVM. Oleh karena itu, standardisasi prediktor diperlukan agar kontribusi setiap variabel terhadap perhitungan jarak tidak semata-mata ditentukan oleh satuan pengukurannya.
Beberapa variabel juga menunjukkan indikasi distribusi menceng ke kanan. Pada residual sugar, rata-rata sebesar 5,4432 lebih tinggi daripada median 3,0000, dengan nilai maksimum 65,8000 yang jauh melampaui kuartil ketiga 8,1000. Nilai maksimum yang relatif tinggi juga ditemukan pada chlorides dan free sulfur dioxide. Kondisi ini menunjukkan perlunya pemeriksaan nilai ekstrem, tetapi nilai tersebut tidak dapat langsung dianggap sebagai kesalahan pengukuran.
Variabel quality merupakan skor penilaian kualitas anggur yang memiliki urutan dari kualitas lebih rendah hingga lebih tinggi. Distribusinya diperiksa untuk mengetahui frekuensi setiap skor dan melihat apakah jumlah observasi tersebar secara merata.
# Menghitung distribusi skor kualitas
distribusi_quality <- wine_data %>%
count(quality) %>%
mutate(persentase = round(n / sum(n) * 100, 2))
knitr::kable(
distribusi_quality,
col.names = c("Skor Kualitas", "Jumlah", "Persentase (%)"),
caption = "Distribusi skor kualitas anggur"
)| Skor Kualitas | Jumlah | Persentase (%) |
|---|---|---|
| 3 | 30 | 0.46 |
| 4 | 216 | 3.32 |
| 5 | 2138 | 32.91 |
| 6 | 2836 | 43.65 |
| 7 | 1079 | 16.61 |
| 8 | 193 | 2.97 |
| 9 | 5 | 0.08 |
Untuk memperjelas perbedaan frekuensi antarlevel kualitas, distribusi skor ditampilkan menggunakan diagram batang.
# Visualisasi distribusi skor kualitas
ggplot(distribusi_quality, aes(x = factor(quality), y = n)) +
geom_col(fill = "#27689B", width = 0.7) +
labs(
title = "Distribusi Skor Kualitas Anggur",
x = "Skor Kualitas",
y = "Jumlah Observasi"
) +
theme_minimal()Distribusi skor kualitas menunjukkan bahwa sebagian besar observasi berada pada skor 5 (32,91%) dan 6 (43,65%), dengan proporsi gabungan sebesar 76,56%. Sebaliknya, skor 3 dan 9 hanya mencakup 0,54% dari seluruh observasi. Konsentrasi ini menunjukkan bahwa kualitas menengah lebih banyak terwakili dibandingkan kualitas yang sangat rendah atau tinggi. Pada regresi, keterbatasan observasi di kedua ujung rentang skor perlu diperhatikan karena ketepatan prediksi pada nilai yang jarang muncul belum tentu sama dengan nilai yang lebih umum.
Jika skor dikelompokkan menjadi Good (skor ≥ 6) dan Not Good (skor < 6), proporsi kedua kelas adalah sekitar 63,31% dan 36,69%. Perbedaan ini perlu diperhatikan dalam evaluasi klasifikasi, sehingga ketepatan model tidak hanya dinilai melalui accuracy, tetapi juga melalui ukuran seperti balanced accuracy dan F1-score.
Pemeriksaan kualitas data dilakukan untuk mengidentifikasi nilai hilang, baris yang memiliki nilai identik, dan observasi dengan nilai numerik yang jauh dari sebagian besar data. Hasil pemeriksaan menjadi dasar untuk menentukan langkah persiapan data sebelum pemodelan.
# Menghitung nilai hilang pada setiap variabel
missing_wine <- wine_data %>%
summarise(across(everything(), ~ sum(is.na(.x)))) %>%
pivot_longer(
cols = everything(),
names_to = "variabel",
values_to = "jumlah_missing"
)
knitr::kable(
missing_wine,
caption = "Jumlah nilai hilang pada setiap variabel"
)| variabel | jumlah_missing |
|---|---|
| type | 0 |
| fixed acidity | 0 |
| volatile acidity | 0 |
| citric acid | 0 |
| residual sugar | 0 |
| chlorides | 0 |
| free sulfur dioxide | 0 |
| total sulfur dioxide | 0 |
| density | 0 |
| pH | 0 |
| sulphates | 0 |
| alcohol | 0 |
| quality | 0 |
Selain nilai hilang, pemeriksaan dilakukan terhadap baris yang memiliki nilai sama pada seluruh variabel.
# Memeriksa baris identik
duplikat_wine <- tibble(
jumlah_observasi = nrow(wine_data),
baris_identik = sum(duplicated(wine_data)),
baris_unik = nrow(distinct(wine_data))
)
knitr::kable(
duplikat_wine,
caption = "Pemeriksaan baris identik"
)| jumlah_observasi | baris_identik | baris_unik |
|---|---|---|
| 6497 | 1177 | 5320 |
Nilai ekstrem pada prediktor numerik diperiksa menggunakan aturan IQR. Observasi ditandai apabila nilainya berada di bawah \(Q_1 - 1{,}5 \times IQR\) atau di atas \(Q_3 + 1{,}5 \times IQR\).
# Mengidentifikasi nilai ekstrem dengan metode IQR
ekstrem_wine <- wine_data %>%
select(where(is.numeric), -quality) %>%
summarise(across(everything(), ~ {
q1 <- quantile(.x, 0.25, na.rm = TRUE)
q3 <- quantile(.x, 0.75, na.rm = TRUE)
iqr <- q3 - q1
batas_bawah <- q1 - 1.5 * iqr
batas_atas <- q3 + 1.5 * iqr
sum(.x < batas_bawah | .x > batas_atas, na.rm = TRUE)
})) %>%
pivot_longer(
cols = everything(),
names_to = "variabel",
values_to = "jumlah_ekstrem"
)
knitr::kable(
ekstrem_wine,
caption = "Jumlah nilai ekstrem berdasarkan aturan IQR"
)| variabel | jumlah_ekstrem |
|---|---|
| fixed acidity | 357 |
| volatile acidity | 377 |
| citric acid | 509 |
| residual sugar | 118 |
| chlorides | 286 |
| free sulfur dioxide | 62 |
| total sulfur dioxide | 10 |
| density | 3 |
| pH | 73 |
| sulphates | 191 |
| alcohol | 3 |
Untuk melihat sebaran data dan keberadaan nilai ekstrem pada setiap variabel fisikokimia, digunakan visualisasi boxplot. Titik yang berada di luar whisker menunjukkan pengamatan yang teridentifikasi sebagai nilai ekstrem berdasarkan aturan 1,5 × IQR.
wine_data %>%
select(where(is.numeric), -quality) %>%
pivot_longer(
cols = everything(),
names_to = "variabel",
values_to = "nilai"
) %>%
ggplot(aes(x = "", y = nilai)) +
geom_boxplot(
fill = "#2C6E9B",
color = "#253746",
outlier.colour = "#D94F4F",
outlier.size = 1,
outlier.alpha = 0.7,
width = 0.5
) +
facet_wrap(~ variabel, scales = "free_y", ncol = 4) +
labs(
x = NULL,
y = "Nilai pengamatan"
) +
theme_minimal(base_size = 11) +
theme(
axis.text.x = element_blank(),
axis.ticks.x = element_blank(),
strip.text = element_text(face = "bold")
)Pemodelan KNN dan SVM dilakukan untuk dua jenis permasalahan, yaitu klasifikasi dan regresi. Pada klasifikasi, skor quality dikelompokkan menjadi dua kategori, yaitu Not Good untuk skor kurang dari 6 dan Good untuk skor 6 atau lebih. Sementara itu, pada regresi, variabel respons tetap berupa skor quality dalam bentuk numerik.
# Membentuk variabel respons untuk klasifikasi
wine_data <- wine_data %>%
mutate(
quality_class = factor(
if_else(quality >= 6, "Good", "Not Good"),
levels = c("Not Good", "Good")
)
)
# Memeriksa distribusi kelas hasil pengelompokan
distribusi_kelas <- wine_data %>%
count(quality_class, name = "frekuensi") %>%
mutate(
persentase = round(100 * frekuensi / sum(frekuensi), 2)
)
knitr::kable(
distribusi_kelas,
caption = "Distribusi kategori kualitas anggur"
)| quality_class | frekuensi | persentase |
|---|---|---|
| Not Good | 2384 | 36.69 |
| Good | 4113 | 63.31 |
# Memastikan variabel respons regresi tetap numerik
class(wine_data$quality)[1] "numeric"
Pengamatan yang memiliki nilai identik pada seluruh variabel dihapus menggunakan fungsi distinct(). Langkah ini dilakukan sebelum pembagian data latih dan uji untuk menghindari keberadaan baris yang sama pada kedua kelompok data.
# Menghapus baris yang identik pada seluruh variabel
wine_clean <- wine_data %>%
distinct()
# Membandingkan jumlah pengamatan
ringkasan_duplikat <- tibble(
tahap = c("Sebelum penghapusan", "Setelah penghapusan"),
jumlah_observasi = c(
nrow(wine_data),
nrow(wine_clean)
)
)
knitr::kable(
ringkasan_duplikat,
caption = "Jumlah pengamatan sebelum dan setelah penghapusan baris identik"
)| tahap | jumlah_observasi |
|---|---|
| Sebelum penghapusan | 6497 |
| Setelah penghapusan | 5320 |
# Memeriksa distribusi kelas setelah penghapusan
wine_clean %>%
count(quality_class, name = "frekuensi") %>%
mutate(
persentase = round(100 * frekuensi / sum(frekuensi), 2)
) %>%
knitr::kable(
caption = "Distribusi kategori kualitas setelah penghapusan baris identik"
)| quality_class | frekuensi | persentase |
|---|---|---|
| Not Good | 1988 | 37.37 |
| Good | 3332 | 62.63 |
Hasil penghapusan menunjukkan bahwa jumlah pengamatan berkurang dari 6.497 menjadi 5.320, sehingga terdapat 1.177 baris identik (18,12%) yang dihapus. Proporsi kelas Good berubah dari 63,31% menjadi 62,63%, sedangkan Not Good meningkat dari 36,69% menjadi 37,37%. Perubahan yang relatif kecil ini menunjukkan bahwa penghapusan baris identik tidak banyak mengubah komposisi kelas. Data yang telah dibersihkan selanjutnya digunakan untuk pembagian data latih dan uji.
Data dibagi menjadi 80% data latih dan 20% data uji menggunakan stratified random sampling berdasarkan kategori quality_class. Pembagian berstrata dilakukan agar proporsi kedua kategori relatif terjaga pada data latih dan uji.
# Pembagian data secara berstrata
set.seed(123)
split_wine <- rsample::initial_split(
wine_clean,
prop = 0.80,
strata = quality_class
)
# Membentuk data latih dan data uji
wine_train <- rsample::training(split_wine)
wine_test <- rsample::testing(split_wine)
# Memeriksa jumlah dan proporsi kelas
ringkasan_split <- bind_rows(
wine_train %>% mutate(kelompok = "Latih"),
wine_test %>% mutate(kelompok = "Uji")
) %>%
count(kelompok, quality_class, name = "frekuensi") %>%
group_by(kelompok) %>%
mutate(
persentase = round(100 * frekuensi / sum(frekuensi), 2)
) %>%
ungroup()
knitr::kable(
ringkasan_split,
caption = "Distribusi kategori kualitas pada data latih dan uji"
)| kelompok | quality_class | frekuensi | persentase |
|---|---|---|---|
| Latih | Not Good | 1590 | 37.37 |
| Latih | Good | 2665 | 62.63 |
| Uji | Not Good | 398 | 37.37 |
| Uji | Good | 667 | 62.63 |
Selanjutnya, kita perlu menyiapkan prediktor untuk KNN dan SVM.
Ada dua proses utama:
Pengkodean kategori: Variabel type diubah menjadi variabel numerik menggunakan dummy encoding.
Standardisasi: Seluruh prediktor distandardisasi menggunakan rata-rata dan simpangan baku data latih.
Standardisasi diperlukan karena KNN menggunakan ukuran jarak, sedangkan SVM dipengaruhi oleh skala prediktor dalam pembentukan batas keputusan. Variabel dengan rentang lebih besar dapat memberikan pengaruh yang tidak proporsional apabila skala prediktor tidak diseragamkan.
Standardisasi menggunakan rumus:
\[z_{ij} = \frac{x_{ij} - \bar{x}_{j,\text{latih}}}{s_{j,\text{latih}}}\]
dengan \(\bar{x}_{j,\text{latih}}\) dan \(s_{j,\text{latih}}\) masing-masing merupakan rata-rata dan simpangan baku prediktor ke-\(j\) pada data latih. Parameter standardisasi dihitung hanya dari data latih dan diterapkan pada data uji untuk mencegah data leakage.
# Menyiapkan prediktor tanpa variabel respons
prediktor_train <- wine_train %>%
select(-quality, -quality_class) %>%
mutate(type = factor(type, levels = c("red", "white")))
prediktor_test <- wine_test %>%
select(-quality, -quality_class) %>%
mutate(type = factor(type, levels = c("red", "white")))
# Mengubah kategori menjadi dummy
x_train <- model.matrix(~ ., data = prediktor_train)[, -1, drop = FALSE]
x_test <- model.matrix(~ ., data = prediktor_test)[, -1, drop = FALSE]
# Menghitung parameter standardisasi dari data latih
rata_rata_train <- colMeans(x_train)
sd_train <- apply(x_train, 2, sd)
# Memastikan tidak ada prediktor dengan simpangan baku nol
stopifnot(all(sd_train > 0))
# Standardisasi data latih dan uji
x_train_scaled <- scale(
x_train,
center = rata_rata_train,
scale = sd_train
)
x_test_scaled <- scale(
x_test,
center = rata_rata_train,
scale = sd_train
)
# Memeriksa hasil standardisasi
ringkasan_skala <- tibble(
variabel = colnames(x_train),
rata_rata_awal = round(colMeans(x_train), 3),
sd_awal = round(apply(x_train, 2, sd), 3),
rata_rata_standar = round(colMeans(x_train_scaled), 3),
sd_standar = round(apply(x_train_scaled, 2, sd), 3)
)
knitr::kable(
ringkasan_skala,
caption = "Perbandingan skala prediktor sebelum dan setelah standardisasi pada data latih"
)| variabel | rata_rata_awal | sd_awal | rata_rata_standar | sd_standar |
|---|---|---|---|---|
| typewhite | 0.748 | 0.434 | 0 | 1 |
fixed acidity |
7.218 | 1.324 | 0 | 1 |
volatile acidity |
0.344 | 0.168 | 0 | 1 |
citric acid |
0.319 | 0.148 | 0 | 1 |
residual sugar |
5.074 | 4.541 | 0 | 1 |
| chlorides | 0.056 | 0.036 | 0 | 1 |
free sulfur dioxide |
30.181 | 17.988 | 0 | 1 |
total sulfur dioxide |
114.371 | 56.846 | 0 | 1 |
| density | 0.995 | 0.003 | 0 | 1 |
| pH | 3.223 | 0.161 | 0 | 1 |
| sulphates | 0.533 | 0.149 | 0 | 1 |
| alcohol | 10.548 | 1.179 | 0 | 1 |
Hasil standardisasi menunjukkan bahwa seluruh prediktor pada data latih telah memiliki rata-rata 0 dan simpangan baku 1. Sebelum standardisasi, terdapat perbedaan skala yang cukup besar, misalnya simpangan baku total sulfur dioxide sebesar 56,846, sedangkan density hanya 0,003. Standardisasi membuat setiap prediktor memiliki skala yang sebanding sehingga perhitungan jarak pada KNN dan pembentukan batas keputusan pada SVM tidak didominasi oleh variabel yang memiliki skala numerik lebih besar. Namun, standardisasi tidak menghilangkan nilai ekstrem yang sebelumnya teridentifikasi.
Klasifikasi menggunakan K-Nearest Neighbors (KNN) dilakukan untuk memprediksi kategori kualitas anggur (Good atau Not Good) berdasarkan karakteristik fisikokimianya. KNN menentukan kelas suatu pengamatan berdasarkan suara mayoritas dari sejumlah (k) tetangga terdekat.
Pemilihan nilai (k) merupakan tahap penting dalam pembentukan model. Nilai (k) yang terlalu kecil cenderung sensitif terhadap variasi lokal dan nilai ekstrem, sedangkan nilai (k) yang terlalu besar dapat mengurangi kemampuan model dalam mengenali pola lokal.
Pada praktikum ini, pemilihan nilai (k) dilakukan dengan ketentuan berikut:
Balanced accuracy digunakan karena jumlah pengamatan pada kedua kategori kualitas tidak sama. Metrik ini menghitung rata-rata sensitivity dan specificity, sehingga kemampuan model mengenali kedua kelas ikut diperhitungkan.
\[\text{Balanced Accuracy} = \frac{\text{Sensitivity}+\text{Specificity}}{2}\]
Selanjutnya, model KNN dibangun untuk setiap kandidat nilai (k), kemudian hasil validasi silang dibandingkan untuk menentukan nilai (k) terbaik.
# Fungsi evaluasi balanced accuracy
ringkasan_knn <- function(data, lev = NULL, model = NULL) {
cm <- caret::confusionMatrix(
data = data$pred,
reference = data$obs,
positive = "Good"
)
c(
BalancedAccuracy = unname(cm$byClass["Balanced Accuracy"]),
Accuracy = unname(cm$overall["Accuracy"])
)
}
# Pengaturan validasi silang
kontrol_knn <- caret::trainControl(
method = "cv",
number = 5,
summaryFunction = ringkasan_knn
)
# Pemilihan nilai k
set.seed(123)
model_knn <- caret::train(
x = x_train,
y = wine_train$quality_class,
method = "knn",
tuneGrid = data.frame(k = seq(3, 25, 2)),
trControl = kontrol_knn,
preProcess = c("center", "scale"),
metric = "BalancedAccuracy"
)Loading required package: lattice
Attaching package: 'caret'
The following object is masked from 'package:kknn':
contr.dummy
The following objects are masked from 'package:yardstick':
precision, recall, sensitivity, specificity
The following object is masked from 'package:rsample':
calibration
The following object is masked from 'package:purrr':
lift
# Menampilkan hasil validasi silang
hasil_knn <- model_knn$results %>%
select(k, BalancedAccuracy, BalancedAccuracySD, Accuracy)
knitr::kable(
hasil_knn,
digits = 4,
caption = "Hasil validasi silang KNN untuk berbagai nilai k"
)| k | BalancedAccuracy | BalancedAccuracySD | Accuracy |
|---|---|---|---|
| 3 | 0.6867 | 0.0068 | 0.7159 |
| 5 | 0.6981 | 0.0085 | 0.7286 |
| 7 | 0.7027 | 0.0113 | 0.7349 |
| 9 | 0.7056 | 0.0117 | 0.7387 |
| 11 | 0.7050 | 0.0097 | 0.7373 |
| 13 | 0.7042 | 0.0134 | 0.7380 |
| 15 | 0.7057 | 0.0138 | 0.7398 |
| 17 | 0.7099 | 0.0148 | 0.7438 |
| 19 | 0.7178 | 0.0159 | 0.7523 |
| 21 | 0.7113 | 0.0209 | 0.7478 |
| 23 | 0.7096 | 0.0154 | 0.7462 |
| 25 | 0.7068 | 0.0162 | 0.7436 |
Balanced accuracy KNN berdasarkan nilai k
# Visualisasi hasil validasi silang
ggplot(hasil_knn, aes(x = k, y = BalancedAccuracy)) +
geom_line(color = "#2C6E9B", linewidth = 1) +
geom_point(color = "#D94F4F", size = 2.5) +
scale_x_continuous(breaks = seq(3, 25, 2)) +
labs(
x = "Jumlah tetangga (k)",
y = "Balanced accuracy",
title = "Pemilihan nilai k pada KNN Classification"
) +
theme_minimal(base_size = 12)# Nilai k terbaik
model_knn$bestTuneBalanced accuracy KNN berdasarkan nilai k
Hasil validasi silang menunjukkan bahwa balanced accuracy KNN meningkat dari 0,6867 pada \(k=3\) hingga mencapai nilai tertinggi 0,7178 pada \(k=19\). Setelah itu, kinerja cenderung menurun hingga 0,7068 pada \(k=25\). Pola ini menunjukkan bahwa penggunaan lebih banyak tetangga awalnya membantu menghasilkan klasifikasi yang lebih baik, tetapi penambahan tetangga tidak selalu meningkatkan kinerja. Berdasarkan kandidat yang diuji, \(k=19\) dipilih sebagai nilai terbaik, dengan accuracy sebesar 0,7523 dan simpangan baku balanced accuracy antar-fold sebesar 0,0159. Selisih kinerja antarbeberapa nilai \(k\) di sekitar titik terbaik relatif kecil, sehingga hasil ini tidak menunjukkan bahwa \(k=19\) pasti lebih unggul pada setiap sampel data.
Model KNN dengan nilai (k) terpilih digunakan untuk memprediksi kategori kualitas anggur pada data uji. Hasil prediksi dibandingkan dengan kategori sebenarnya melalui matriks konfusi. Kinerja klasifikasi kemudian diringkas menggunakan accuracy, balanced accuracy, sensitivity, specificity, precision, dan F1-score.
Accuracy: Proporsi seluruh prediksi yang benar.
Balanced accuracy: Rata-rata kemampuan model mengenali kedua kelas.
Sensitivity: Proporsi anggur Good yang berhasil dikenali.
Specificity: Proporsi anggur Not Good yang berhasil dikenali.
Precision: Proporsi prediksi Good yang benar-benar termasuk Good.
F1-score: Rata-rata harmonik antara precision dan sensitivity.
# Melakukan prediksi pada data uji
prediksi_knn <- predict(
model_knn,
newdata = x_test
)
# Membentuk matriks konfusi
evaluasi_knn <- caret::confusionMatrix(
data = prediksi_knn,
reference = wine_test$quality_class,
positive = "Good",
mode = "everything"
)
knitr::kable(
as.data.frame.matrix(evaluasi_knn$table),
caption = "Matriks konfusi KNN pada data uji"
)| Not Good | Good | |
|---|---|---|
| Not Good | 225 | 97 |
| Good | 173 | 570 |
# Merangkum metrik evaluasi
metrik_knn <- tibble(
metrik = c(
"Accuracy",
"Balanced Accuracy",
"Sensitivity",
"Specificity",
"Precision",
"F1-score"
),
nilai = round(c(
evaluasi_knn$overall["Accuracy"],
evaluasi_knn$byClass["Balanced Accuracy"],
evaluasi_knn$byClass["Sensitivity"],
evaluasi_knn$byClass["Specificity"],
evaluasi_knn$byClass["Precision"],
evaluasi_knn$byClass["F1"]
), 4)
)
knitr::kable(
metrik_knn,
caption = "Kinerja KNN Classification pada data uji"
)| metrik | nilai |
|---|---|
| Accuracy | 0.7465 |
| Balanced Accuracy | 0.7099 |
| Sensitivity | 0.8546 |
| Specificity | 0.5653 |
| Precision | 0.7672 |
| F1-score | 0.8085 |
Gunakan x_test, bukan x_test_scaled, saat menjalankan predict(). Model yang dibangun melalui caret::train() sudah menyimpan proses standardisasi sehingga transformasi diterapkan secara otomatis pada prediktor baru. Menggunakan data yang sudah distandardisasi akan menyebabkan standardisasi dilakukan dua kali.
Hasil pengujian menunjukkan bahwa KNN menghasilkan accuracy sebesar 0,7465 dan balanced accuracy sebesar 0,7099. Berdasarkan matriks konfusi, model berhasil mengklasifikasikan 570 anggur berkualitas Good dan 225 anggur berkualitas Not Good dengan benar. Namun, sebanyak 173 pengamatan Not Good diprediksi sebagai Good, sedangkan 97 pengamatan Good diprediksi sebagai Not Good.
Nilai sensitivity sebesar 0,8546 menunjukkan bahwa model mampu mengenali 85,46% pengamatan Good, sedangkan specificity sebesar 0,5653 menunjukkan bahwa hanya 56,53% pengamatan Not Good yang berhasil dikenali. Dengan demikian, model lebih baik dalam mengidentifikasi kategori Good dibandingkan Not Good. Nilai precision sebesar 0,7672 dan F1-score sebesar 0,8085 juga menggambarkan kinerja model terhadap kelas Good. Perbedaan kemampuan mengenali kedua kelas ini perlu diperhatikan meskipun nilai accuracy keseluruhan relatif lebih tinggi.
KNN Regression digunakan untuk memprediksi skor kualitas anggur (quality) berdasarkan karakteristik fisikokimianya. Berbeda dengan klasifikasi yang menggunakan suara mayoritas, regresi KNN menghasilkan prediksi numerik melalui rata-rata nilai respons dari (k) tetangga terdekat.
Secara matematis, prediksi KNN Regression dinyatakan sebagai:
\[\hat{y}(\mathbf{x}) = \frac{1}{k} \sum_{i \in N_k(\mathbf{x})} y_i\]
dengan:
Nilai (k) dipilih menggunakan 5-fold cross-validation pada data latih. Berbeda dengan klasifikasi biner, regresi tidak memerlukan nilai (k) ganjil karena prediksi dihitung menggunakan rata-rata, bukan suara mayoritas.
Pada praktikum ini, nilai (k) genap dari 2 sampai 30 dievaluasi menggunakan Root Mean Squared Error (RMSE). RMSE mengukur besarnya kesalahan prediksi dalam satuan yang sama dengan variabel respons.
\[RMSE = \sqrt{ \frac{1}{n} \sum_{i=1}^{n} (y_i-\hat{y}_i)^2 }\]
Semakin kecil RMSE, semakin dekat hasil prediksi dengan nilai aktual. Nilai (k) dengan rata-rata RMSE validasi silang terendah dipilih sebagai parameter terbaik.
# Pengaturan validasi silang
kontrol_knn_reg <- caret::trainControl(
method = "cv",
number = 5
)
# Pemilihan nilai k
set.seed(123)
model_knn_reg <- caret::train(
x = x_train,
y = wine_train$quality,
method = "knn",
tuneGrid = data.frame(k = seq(2, 30, 2)),
trControl = kontrol_knn_reg,
preProcess = c("center", "scale"),
metric = "RMSE"
)
# Menampilkan hasil validasi silang
hasil_knn_reg <- model_knn_reg$results %>%
select(k, RMSE, RMSESD, Rsquared, MAE)
knitr::kable(
hasil_knn_reg,
digits = 4,
caption = "Hasil validasi silang KNN Regression"
)| k | RMSE | RMSESD | Rsquared | MAE |
|---|---|---|---|---|
| 2 | 0.8133 | 0.0361 | 0.2460 | 0.5978 |
| 4 | 0.7561 | 0.0369 | 0.2886 | 0.5787 |
| 6 | 0.7367 | 0.0338 | 0.3091 | 0.5655 |
| 8 | 0.7302 | 0.0346 | 0.3158 | 0.5650 |
| 10 | 0.7281 | 0.0350 | 0.3176 | 0.5659 |
| 12 | 0.7231 | 0.0362 | 0.3257 | 0.5633 |
| 14 | 0.7229 | 0.0347 | 0.3259 | 0.5633 |
| 16 | 0.7204 | 0.0361 | 0.3308 | 0.5627 |
| 18 | 0.7192 | 0.0368 | 0.3333 | 0.5619 |
| 20 | 0.7192 | 0.0379 | 0.3338 | 0.5621 |
| 22 | 0.7197 | 0.0375 | 0.3334 | 0.5629 |
| 24 | 0.7193 | 0.0382 | 0.3346 | 0.5632 |
| 26 | 0.7206 | 0.0385 | 0.3328 | 0.5647 |
| 28 | 0.7196 | 0.0389 | 0.3353 | 0.5646 |
| 30 | 0.7195 | 0.0389 | 0.3357 | 0.5648 |
RMSE KNN Regression berdasarkan nilai k
# Visualisasi RMSE untuk setiap nilai k
ggplot(hasil_knn_reg, aes(x = k, y = RMSE)) +
geom_line(color = "#2C6E9B", linewidth = 1) +
geom_point(color = "#D94F4F", size = 2.5) +
scale_x_continuous(breaks = seq(2, 30, 2)) +
labs(
x = "Jumlah tetangga (k)",
y = "RMSE",
title = "Pemilihan nilai k pada KNN Regression"
) +
theme_minimal(base_size = 12)# Menampilkan nilai k terbaik
model_knn_reg$bestTuneRMSE KNN Regression berdasarkan nilai k
Hasil validasi silang menunjukkan bahwa RMSE KNN Regression menurun dari 0,8133 pada \(k=2\) menjadi sekitar 0,7192 pada \(k=18\)–\(20\). Penurunan yang cukup besar pada nilai \(k\) kecil menunjukkan bahwa penggunaan lebih banyak tetangga membantu mengurangi kesalahan prediksi. Namun, mulai sekitar \(k=18\), RMSE relatif stabil sehingga penambahan tetangga tidak lagi menghasilkan perbaikan yang berarti. Berdasarkan hasil pemilihan parameter, \(k=20\) terpilih dengan RMSE 0,7192, MAE 0,5621, dan Rsquared 0,3338. Nilai RMSE pada \(k=18\) dan \(k=20\) sama setelah pembulatan empat desimal, sehingga keunggulan \(k=20\) perlu dipahami sebagai hasil pemilihan berdasarkan nilai RMSE sebelum pembulatan, bukan perbedaan kinerja yang besar.
Model KNN Regression dengan nilai (k) terpilih digunakan untuk memprediksi skor kualitas anggur pada data uji. Kinerja model dievaluasi menggunakan RMSE, MAE, dan Rsquared. Selain itu, hubungan antara skor aktual dan hasil prediksi divisualisasikan menggunakan diagram pencar.
Pada diagram pencar, garis diagonal menunjukkan kondisi ketika hasil prediksi sama dengan nilai aktual. Semakin dekat titik pengamatan terhadap garis tersebut, semakin kecil kesalahan prediksinya.
# Melakukan prediksi pada data uji
prediksi_knn_reg <- predict(
model_knn_reg,
newdata = x_test
)
# Menghitung metrik evaluasi
hasil_evaluasi_knn_reg <- caret::postResample(
pred = prediksi_knn_reg,
obs = wine_test$quality
)
metrik_knn_reg <- tibble(
metrik = names(hasil_evaluasi_knn_reg),
nilai = round(as.numeric(hasil_evaluasi_knn_reg), 4)
)
knitr::kable(
metrik_knn_reg,
caption = "Kinerja KNN Regression pada data uji"
)| metrik | nilai |
|---|---|
| RMSE | 0.7145 |
| Rsquared | 0.3521 |
| MAE | 0.5598 |
Perbandingan skor kualitas aktual dan prediksi KNN Regression
# Menyiapkan data untuk visualisasi
perbandingan_knn_reg <- tibble(
aktual = wine_test$quality,
prediksi = as.numeric(prediksi_knn_reg)
)
# Visualisasi nilai aktual dan prediksi
ggplot(perbandingan_knn_reg, aes(x = aktual, y = prediksi)) +
geom_jitter(
width = 0.12,
height = 0,
color = "#2C6E9B",
alpha = 0.35,
size = 1.5
) +
geom_abline(
slope = 1,
intercept = 0,
linetype = "dashed",
color = "#D94F4F",
linewidth = 1
) +
scale_x_continuous(breaks = 3:9) +
labs(
x = "Skor kualitas aktual",
y = "Skor kualitas prediksi",
title = "Nilai Aktual vs Prediksi KNN Regression"
) +
theme_minimal(base_size = 12)Dalam caret::postResample(), \(R^2\) dihitung sebagai kuadrat korelasi antara nilai aktual dan prediksi. Jadi, metrik ini tidak selalu identik dengan koefisien determinasi berbasis \(1-\mathrm{SSE}/\mathrm{SST}\).
Pada data uji, KNN Regression menghasilkan RMSE sebesar 0,7145 dan MAE sebesar 0,5598. Artinya, rata-rata kesalahan absolut prediksi sekitar 0,56 poin pada skala kualitas anggur, sedangkan RMSE yang lebih besar menunjukkan adanya kesalahan prediksi yang relatif tinggi pada sebagian pengamatan. Nilai Rsquared sebesar 0,3521 menunjukkan hubungan antara nilai aktual dan prediksi yang masih terbatas.
Diagram pencar memperlihatkan bahwa prediksi cenderung terkonsentrasi di sekitar skor 5 hingga 7. Pengamatan dengan skor aktual rendah, terutama 3 dan 4, cenderung diprediksi lebih tinggi, sedangkan pengamatan dengan skor 7 hingga 9 cenderung diprediksi lebih rendah. Pola ini menunjukkan kecenderungan prediksi menuju nilai tengah karena KNN Regression menggunakan rata-rata respons dari tetangga terdekat. Dengan demikian, model belum sepenuhnya mampu menangkap variasi skor kualitas, khususnya pada pengamatan dengan nilai ekstrem.
Support Vector Machine (SVM) merupakan metode klasifikasi yang mencari batas keputusan (hyperplane) untuk memisahkan pengamatan dari kelas yang berbeda. SVM berusaha memperoleh batas keputusan dengan margin yang besar, yaitu jarak antara batas keputusan dan pengamatan terdekat dari masing-masing kelas. Pengamatan yang menentukan batas tersebut disebut support vectors.
Pada praktikum ini, digunakan SVM dengan kernel Radial Basis Function (RBF) untuk memungkinkan pembentukan batas keputusan nonlinier. Kernel RBF dinyatakan sebagai:
\[K(\mathbf{x}_i,\mathbf{x}_j) = \exp\left( -\sigma\|\mathbf{x}_i-\mathbf{x}_j\|^2 \right)\]
dengan:
Kinerja SVM dipengaruhi oleh dua parameter utama, yaitu (C) dan (). Parameter (C) mengatur penalti kesalahan klasifikasi. Nilai (C) yang besar memberikan penalti lebih tinggi terhadap kesalahan, sedangkan nilai yang kecil memungkinkan model lebih toleran terhadap kesalahan. Sementara itu, nilai () yang lebih besar membuat pengaruh setiap pengamatan semakin lokal sehingga batas keputusan dapat menjadi lebih kompleks.
Pemilihan parameter dilakukan menggunakan grid search dengan 5-fold cross-validation. Setiap kombinasi (C) dan () dievaluasi berdasarkan balanced accuracy, kemudian kombinasi dengan rata-rata tertinggi dipilih untuk membangun model akhir.
# Fungsi evaluasi balanced accuracy
ringkasan_svm <- function(data, lev = NULL, model = NULL) {
cm <- caret::confusionMatrix(
data = data$pred,
reference = data$obs,
positive = "Good"
)
c(
BalancedAccuracy = unname(cm$byClass["Balanced Accuracy"]),
Accuracy = unname(cm$overall["Accuracy"])
)
}
# Pengaturan validasi silang
kontrol_svm <- caret::trainControl(
method = "cv",
number = 5,
summaryFunction = ringkasan_svm
)
# Menentukan kombinasi parameter
grid_svm <- expand.grid(
sigma = c(0.02, 0.08, 0.20),
C = c(0.1, 1, 10)
)
# Melatih dan memilih model terbaik
set.seed(123)
model_svm <- caret::train(
x = x_train,
y = wine_train$quality_class,
method = "svmRadial",
tuneGrid = grid_svm,
trControl = kontrol_svm,
preProcess = c("center", "scale"),
metric = "BalancedAccuracy"
)
# Menampilkan hasil validasi silang
hasil_svm <- model_svm$results %>%
select(sigma, C, BalancedAccuracy, BalancedAccuracySD, Accuracy)
knitr::kable(
hasil_svm,
digits = 4,
caption = "Hasil validasi silang SVM Classification"
)| sigma | C | BalancedAccuracy | BalancedAccuracySD | Accuracy |
|---|---|---|---|---|
| 0.02 | 0.1 | 0.6878 | 0.0152 | 0.7311 |
| 0.02 | 1.0 | 0.7203 | 0.0199 | 0.7506 |
| 0.02 | 10.0 | 0.7286 | 0.0244 | 0.7572 |
| 0.08 | 0.1 | 0.7111 | 0.0149 | 0.7459 |
| 0.08 | 1.0 | 0.7418 | 0.0206 | 0.7669 |
| 0.08 | 10.0 | 0.7415 | 0.0125 | 0.7645 |
| 0.20 | 0.1 | 0.6983 | 0.0153 | 0.7429 |
| 0.20 | 1.0 | 0.7451 | 0.0131 | 0.7687 |
| 0.20 | 10.0 | 0.7226 | 0.0063 | 0.7481 |
Balanced accuracy SVM untuk berbagai kombinasi parameter
# Visualisasi kombinasi parameter
ggplot(
hasil_svm,
aes(
x = factor(C),
y = factor(sigma),
fill = BalancedAccuracy
)
) +
geom_tile(color = "white", linewidth = 1) +
geom_text(
aes(label = sprintf("%.3f", BalancedAccuracy)),
size = 4
) +
scale_fill_gradient(
low = "#D8EAF5",
high = "#2C6E9B"
) +
labs(
x = "Parameter C",
y = "Parameter sigma",
fill = "Balanced accuracy",
title = "Pemilihan Parameter SVM Classification"
) +
theme_minimal(base_size = 12)# Menampilkan parameter terbaik
model_svm$bestTuneBalanced accuracy SVM untuk berbagai kombinasi parameter
Hasil validasi silang menunjukkan bahwa kombinasi (C=1) dan (,20) menghasilkan balanced accuracy tertinggi, yaitu 0,7451, dengan accuracy sebesar 0,7687. Pada (C=0,1), kinerja cenderung lebih rendah untuk seluruh nilai () yang diuji. Peningkatan (C) menjadi 1 memperbaiki hasil klasifikasi, tetapi peningkatan lebih lanjut menjadi 10 tidak selalu memberikan perbaikan.
Pengaruh () juga bergantung pada nilai (C). Sebagai contoh, pada (C=1), balanced accuracy meningkat dari 0,7203 menjadi 0,7451 ketika () dinaikkan dari 0,02 menjadi 0,20. Namun, pada (C=10), penggunaan (,20) justru menghasilkan kinerja lebih rendah. Hal ini menunjukkan pentingnya pemilihan kedua parameter secara bersamaan. Meskipun demikian, selisih kinerja beberapa kombinasi terbaik relatif kecil dibandingkan variasi antar-fold, sehingga kombinasi terpilih merupakan yang terbaik di antara kandidat yang diuji, bukan jaminan terbaik untuk seluruh kemungkinan parameter.
Model SVM dengan parameter (C=1) dan (,20) digunakan untuk memprediksi kategori kualitas anggur pada data uji. Hasil prediksi dibandingkan dengan kategori aktual melalui matriks konfusi. Kinerja model kemudian diukur menggunakan accuracy, balanced accuracy, sensitivity, specificity, precision, dan F1-score.
# Melakukan prediksi pada data uji
prediksi_svm <- predict(
model_svm,
newdata = x_test
)
# Membentuk matriks konfusi
evaluasi_svm <- caret::confusionMatrix(
data = prediksi_svm,
reference = wine_test$quality_class,
positive = "Good",
mode = "everything"
)
knitr::kable(
as.data.frame.matrix(evaluasi_svm$table),
caption = "Matriks konfusi SVM pada data uji"
)| Not Good | Good | |
|---|---|---|
| Not Good | 257 | 108 |
| Good | 141 | 559 |
# Merangkum metrik evaluasi
metrik_svm <- tibble(
metrik = c(
"Accuracy",
"Balanced Accuracy",
"Sensitivity",
"Specificity",
"Precision",
"F1-score"
),
nilai = round(c(
evaluasi_svm$overall["Accuracy"],
evaluasi_svm$byClass["Balanced Accuracy"],
evaluasi_svm$byClass["Sensitivity"],
evaluasi_svm$byClass["Specificity"],
evaluasi_svm$byClass["Precision"],
evaluasi_svm$byClass["F1"]
), 4)
)
knitr::kable(
metrik_svm,
caption = "Kinerja SVM Classification pada data uji"
)| metrik | nilai |
|---|---|
| Accuracy | 0.7662 |
| Balanced Accuracy | 0.7419 |
| Sensitivity | 0.8381 |
| Specificity | 0.6457 |
| Precision | 0.7986 |
| F1-score | 0.8178 |
Pada data uji, SVM menghasilkan accuracy sebesar 0,7662 dan balanced accuracy sebesar 0,7419. Berdasarkan matriks konfusi, model berhasil mengklasifikasikan 559 pengamatan Good dan 257 pengamatan Not Good dengan benar. Sementara itu, sebanyak 141 pengamatan Not Good diprediksi sebagai Good, dan 108 pengamatan Good diprediksi sebagai Not Good.
Nilai sensitivity sebesar 0,8381 menunjukkan bahwa model mampu mengenali 83,81% pengamatan Good, sedangkan specificity sebesar 0,6457 menunjukkan bahwa 64,57% pengamatan Not Good berhasil dikenali. Dengan demikian, SVM masih lebih baik dalam mengidentifikasi kelas Good, tetapi perbedaan kemampuan mengenali kedua kelas lebih kecil dibandingkan KNN Classification. Nilai precision sebesar 0,7986 dan F1-score sebesar 0,8178 juga menunjukkan bahwa prediksi terhadap kelas Good memiliki tingkat ketepatan yang cukup baik.
Support Vector Regression (SVR) merupakan pengembangan SVM untuk memprediksi variabel respons numerik. Pada praktikum ini, SVR digunakan untuk memprediksi skor kualitas anggur (quality) berdasarkan karakteristik fisikokimianya.
Berbeda dengan regresi yang meminimalkan seluruh kesalahan prediksi secara langsung, SVR menggunakan konsep epsilon-insensitive loss. Melalui konsep ini, kesalahan prediksi yang berada dalam batas toleransi () tidak dikenai penalti.
Fungsi kerugian tersebut dinyatakan sebagai:
\[L_{\epsilon}(y_i,\hat{y}_i) = \max\left(0,\lvert y_i-\hat{y}_i\rvert-\epsilon\right)\]
dengan:
Dengan demikian, SVR berusaha membentuk fungsi prediksi yang tidak terlalu kompleks sekaligus membatasi kesalahan yang melebihi toleransi tersebut.
Pada praktikum ini, digunakan SVR dengan kernel Radial Basis Function (RBF). Kinerja model dipengaruhi oleh parameter (C), yang mengatur penalti terhadap kesalahan di luar batas toleransi, dan (), yang mengatur karakteristik kernel RBF.
Pemilihan parameter dilakukan menggunakan grid search dengan 5-fold cross-validation. Setiap kombinasi dievaluasi berdasarkan RMSE, dan kombinasi dengan rata-rata RMSE terendah dipilih sebagai parameter terbaik. Parameter () ditetapkan sebesar 0,1 selama proses pemodelan.
# Pengaturan validasi silang
kontrol_svr <- caret::trainControl(
method = "cv",
number = 5
)
# Menentukan kombinasi parameter
grid_svr <- expand.grid(
sigma = c(0.02, 0.08, 0.20),
C = c(0.1, 1, 10)
)
# Melatih dan memilih model SVR
set.seed(123)
model_svr <- caret::train(
x = x_train,
y = wine_train$quality,
method = "svmRadial",
tuneGrid = grid_svr,
trControl = kontrol_svr,
preProcess = c("center", "scale"),
metric = "RMSE",
epsilon = 0.1
)
# Menampilkan hasil validasi silang
hasil_svr <- model_svr$results %>%
select(sigma, C, RMSE, RMSESD, Rsquared, MAE)
knitr::kable(
hasil_svr,
digits = 4,
caption = "Hasil validasi silang Support Vector Regression"
)| sigma | C | RMSE | RMSESD | Rsquared | MAE |
|---|---|---|---|---|---|
| 0.02 | 0.1 | 0.7252 | 0.0440 | 0.3247 | 0.5600 |
| 0.02 | 1.0 | 0.7080 | 0.0447 | 0.3524 | 0.5451 |
| 0.02 | 10.0 | 0.7022 | 0.0459 | 0.3645 | 0.5378 |
| 0.08 | 0.1 | 0.7125 | 0.0424 | 0.3455 | 0.5465 |
| 0.08 | 1.0 | 0.6969 | 0.0402 | 0.3728 | 0.5293 |
| 0.08 | 10.0 | 0.7125 | 0.0314 | 0.3550 | 0.5415 |
| 0.20 | 0.1 | 0.7193 | 0.0373 | 0.3359 | 0.5475 |
| 0.20 | 1.0 | 0.7052 | 0.0335 | 0.3588 | 0.5332 |
| 0.20 | 10.0 | 0.7676 | 0.0303 | 0.2946 | 0.5888 |
RMSE SVR untuk berbagai kombinasi parameter
# Visualisasi kombinasi parameter
ggplot(
hasil_svr,
aes(
x = factor(C),
y = factor(sigma),
fill = RMSE
)
) +
geom_tile(color = "white", linewidth = 1) +
geom_text(
aes(label = sprintf("%.3f", RMSE)),
size = 4
) +
scale_fill_gradient(
low = "#BFDDEB",
high = "#F19C79"
) +
labs(
x = "Parameter C",
y = "Parameter sigma",
fill = "RMSE",
title = "Pemilihan Parameter Support Vector Regression"
) +
theme_minimal(base_size = 12)# Menampilkan parameter terbaik
model_svr$bestTuneRMSE SVR untuk berbagai kombinasi parameter
Hasil validasi silang menunjukkan bahwa kombinasi (C=1) dan (,08) menghasilkan RMSE terendah sebesar 0,6969, dengan MAE 0,5293 dan Rsquared 0,3728. Pada (C=1), RMSE menurun ketika () meningkat dari 0,02 menjadi 0,08, tetapi kembali meningkat pada (,20). Sementara itu, kombinasi (C=10) dan (,20) menghasilkan RMSE tertinggi sebesar 0,7676.
Pola tersebut menunjukkan bahwa pengaruh parameter (C) dan () saling berkaitan. Penalti kesalahan yang lebih besar dan pengaruh kernel yang semakin lokal tidak selalu menghasilkan prediksi yang lebih baik. Berdasarkan kombinasi yang diuji, (C=1) dan (,08) dipilih untuk membangun model SVR akhir, yang selanjutnya dievaluasi menggunakan data uji.
Model SVR dengan parameter (C=1) dan (,08) digunakan untuk memprediksi skor kualitas anggur pada data uji. Hasil prediksi dievaluasi menggunakan RMSE, MAE, dan Rsquared.
Hubungan antara nilai aktual dan prediksi juga divisualisasikan menggunakan diagram pencar. Garis diagonal menunjukkan kondisi prediksi sempurna, sehingga jarak titik terhadap garis tersebut membantu menggambarkan besarnya kesalahan prediksi.
# Melakukan prediksi pada data uji
prediksi_svr <- predict(
model_svr,
newdata = x_test
)
# Menghitung metrik evaluasi
hasil_evaluasi_svr <- caret::postResample(
pred = prediksi_svr,
obs = wine_test$quality
)
metrik_svr <- tibble(
metrik = names(hasil_evaluasi_svr),
nilai = round(as.numeric(hasil_evaluasi_svr), 4)
)
knitr::kable(
metrik_svr,
caption = "Kinerja Support Vector Regression pada data uji"
)| metrik | nilai |
|---|---|
| RMSE | 0.6864 |
| Rsquared | 0.3974 |
| MAE | 0.5221 |
Perbandingan skor kualitas aktual dan prediksi SVR
# Menyiapkan data untuk visualisasi
perbandingan_svr <- tibble(
aktual = wine_test$quality,
prediksi = as.numeric(prediksi_svr)
)
# Visualisasi nilai aktual dan prediksi
ggplot(perbandingan_svr, aes(x = aktual, y = prediksi)) +
geom_jitter(
width = 0.12,
height = 0,
color = "#2C6E9B",
alpha = 0.35,
size = 1.5
) +
geom_abline(
slope = 1,
intercept = 0,
linetype = "dashed",
color = "#D94F4F",
linewidth = 1
) +
scale_x_continuous(breaks = 3:9) +
labs(
x = "Skor kualitas aktual",
y = "Skor kualitas prediksi",
title = "Nilai Aktual vs Prediksi SVR"
) +
theme_minimal(base_size = 12)Pada data uji, SVR menghasilkan RMSE sebesar 0,6864 dan MAE sebesar 0,5221. Nilai MAE menunjukkan bahwa rata-rata kesalahan absolut prediksi sekitar 0,52 poin kualitas anggur. Sementara itu, Rsquared sebesar 0,3974 menunjukkan adanya hubungan antara skor aktual dan prediksi, meskipun kemampuan model dalam merepresentasikan variasi skor masih terbatas.
Diagram pencar menunjukkan bahwa skor kualitas rendah, terutama 3 dan 4, cenderung diprediksi lebih tinggi, sedangkan skor 8 dan 9 cenderung diprediksi lebih rendah. Sebagian besar hasil prediksi masih berada di sekitar skor 5 hingga 7. Dengan demikian, SVR belum sepenuhnya mampu memprediksi skor kualitas ekstrem secara akurat, tetapi menghasilkan kesalahan prediksi yang lebih kecil dibandingkan KNN Regression pada data uji yang sama.
Perbandingan KNN Classification dan SVM Classification dilakukan menggunakan hasil evaluasi pada data uji yang sama. Metrik yang digunakan meliputi accuracy, balanced accuracy, sensitivity, specificity, precision, dan F1-score.
Balanced accuracy menjadi ukuran utama karena mempertimbangkan kemampuan model mengenali kedua kategori kualitas. Sensitivity dan specificity juga dibandingkan untuk melihat apakah kedua model memiliki perbedaan kemampuan dalam mengklasifikasikan anggur Good dan Not Good.
# Menggabungkan metrik kedua model
perbandingan_klasifikasi <- bind_rows(
metrik_knn %>% mutate(model = "KNN"),
metrik_svm %>% mutate(model = "SVM")
)
# Menampilkan tabel perbandingan
perbandingan_klasifikasi %>%
pivot_wider(
names_from = metrik,
values_from = nilai
) %>%
knitr::kable(
digits = 4,
caption = "Perbandingan kinerja model klasifikasi pada data uji"
)| model | Accuracy | Balanced Accuracy | Sensitivity | Specificity | Precision | F1-score |
|---|---|---|---|---|---|---|
| KNN | 0.7465 | 0.7099 | 0.8546 | 0.5653 | 0.7672 | 0.8085 |
| SVM | 0.7662 | 0.7419 | 0.8381 | 0.6457 | 0.7986 | 0.8178 |
Perbandingan kinerja KNN dan SVM Classification
# Memilih metrik utama untuk visualisasi
plot_klasifikasi <- perbandingan_klasifikasi %>%
filter(
metrik %in% c(
"Balanced Accuracy",
"Sensitivity",
"Specificity"
)
)
# Visualisasi perbandingan
ggplot(
plot_klasifikasi,
aes(x = metrik, y = nilai, fill = model)
) +
geom_col(
position = position_dodge(width = 0.75),
width = 0.7
) +
scale_fill_manual(
values = c(
"KNN" = "#2C6E9B",
"SVM" = "#D94F4F"
)
) +
scale_y_continuous(
limits = c(0, 1),
breaks = seq(0, 1, 0.2)
) +
labs(
x = "Metrik evaluasi",
y = "Nilai",
fill = "Model",
title = "Perbandingan KNN dan SVM Classification"
) +
theme_minimal(base_size = 12)Perbandingan pada data uji menunjukkan bahwa SVM memiliki balanced accuracy sebesar 0,7419, lebih tinggi daripada KNN sebesar 0,7099. SVM juga menghasilkan accuracy, precision, dan F1-score yang lebih tinggi. Keunggulan SVM terutama terlihat pada specificity, yang meningkat dari 0,5653 pada KNN menjadi 0,6457 pada SVM. Artinya, SVM lebih mampu mengenali anggur berkualitas Not Good.
Sebaliknya, KNN memiliki sensitivity sedikit lebih tinggi, yaitu 0,8546 dibandingkan 0,8381 pada SVM, sehingga lebih banyak pengamatan Good yang berhasil dikenali. Dengan mempertimbangkan kemampuan mengenali kedua kelas secara seimbang, SVM menunjukkan kinerja yang lebih baik pada data uji ini. Namun, perbandingan tersebut bersifat deskriptif berdasarkan satu pembagian data, sehingga belum membuktikan bahwa keunggulan SVM berlaku secara konsisten pada pembagian data lainnya.
Kinerja KNN Regression dan Support Vector Regression (SVR) dibandingkan menggunakan hasil prediksi pada data uji yang sama. Perbandingan dilakukan berdasarkan RMSE, MAE, dan Rsquared.
RMSE dan MAE digunakan untuk menilai besarnya kesalahan prediksi, sedangkan Rsquared menggambarkan kekuatan hubungan antara nilai aktual dan prediksi. Visualisasi difokuskan pada RMSE dan MAE karena kedua metrik tersebut dinyatakan dalam satuan skor kualitas anggur dan dapat dibandingkan secara langsung.
# Menggabungkan hasil evaluasi regresi
perbandingan_regresi <- bind_rows(
metrik_knn_reg %>% mutate(model = "KNN Regression"),
metrik_svr %>% mutate(model = "SVR")
)
# Menampilkan tabel perbandingan
perbandingan_regresi %>%
pivot_wider(
names_from = metrik,
values_from = nilai
) %>%
knitr::kable(
digits = 4,
caption = "Perbandingan kinerja model regresi pada data uji"
)| model | RMSE | Rsquared | MAE |
|---|---|---|---|
| KNN Regression | 0.7145 | 0.3521 | 0.5598 |
| SVR | 0.6864 | 0.3974 | 0.5221 |
Perbandingan kesalahan prediksi KNN Regression dan SVR
# Memilih metrik kesalahan untuk visualisasi
plot_regresi <- perbandingan_regresi %>%
filter(metrik %in% c("RMSE", "MAE"))
# Visualisasi perbandingan RMSE dan MAE
ggplot(
plot_regresi,
aes(x = metrik, y = nilai, fill = model)
) +
geom_col(
position = position_dodge(width = 0.75),
width = 0.7
) +
geom_text(
aes(label = sprintf("%.4f", nilai)),
position = position_dodge(width = 0.75),
vjust = -0.5,
size = 4
) +
scale_fill_manual(
values = c(
"KNN Regression" = "#2C6E9B",
"SVR" = "#D94F4F"
)
) +
scale_y_continuous(
limits = c(0, 0.85),
breaks = seq(0, 0.8, 0.2)
) +
labs(
x = "Metrik evaluasi",
y = "Nilai kesalahan",
fill = "Model",
title = "Perbandingan KNN Regression dan SVR"
) +
theme_minimal(base_size = 12)Hasil perbandingan menunjukkan bahwa SVR menghasilkan RMSE sebesar 0,6864, lebih rendah daripada KNN Regression sebesar 0,7145. Nilai MAE SVR juga lebih kecil, yaitu 0,5221 dibandingkan 0,5598 pada KNN Regression. Sementara itu, Rsquared SVR sebesar 0,3974 lebih tinggi daripada KNN Regression sebesar 0,3521. Ketiga metrik tersebut menunjukkan bahwa SVR memberikan prediksi yang lebih baik pada data uji.
Meskipun demikian, kedua model masih cenderung menghasilkan prediksi yang mendekati skor kualitas tengah. Pengamatan dengan kualitas sangat rendah atau tinggi belum dapat diprediksi secara akurat. Dengan demikian, SVR merupakan model regresi terbaik di antara kedua metode yang diuji, tetapi masih memiliki keterbatasan dalam menangkap variasi skor kualitas anggur, khususnya pada nilai ekstrem.
Penerapan KNN dan SVM pada data kualitas anggur menunjukkan bahwa pemilihan metode perlu disesuaikan dengan tujuan pemodelan. Pada klasifikasi, SVM menghasilkan balanced accuracy lebih tinggi dibandingkan KNN serta lebih baik dalam mengenali kategori Not Good, meskipun KNN memiliki sensitivity sedikit lebih tinggi untuk kategori Good. Pada regresi, SVR menghasilkan RMSE dan MAE lebih rendah dibandingkan KNN Regression, tetapi kedua metode masih memiliki keterbatasan dalam memprediksi skor kualitas yang ekstrem.
Hasil ini juga memperlihatkan pentingnya standardisasi prediktor, pemilihan parameter melalui validasi silang, dan evaluasi menggunakan data uji yang terpisah. Penilaian kinerja tidak cukup didasarkan pada satu metrik, melainkan perlu mempertimbangkan karakteristik variabel respons dan jenis kesalahan prediksi. Secara keseluruhan, SVM dengan kernel RBF menunjukkan kinerja lebih baik pada kedua tugas dalam pengujian ini, tetapi hasil tersebut belum dapat digeneralisasikan tanpa evaluasi pada pembagian atau kumpulan data lainnya.
Cortes, C., & Vapnik, V. (1995). Support-vector networks. Machine Learning, 20(3), 273–297. https://doi.org/10.1007/BF00994018
Cortez, P., Cerdeira, A., Almeida, F., Matos, T., & Reis, J. (2009a). Modeling wine preferences by data mining from physicochemical properties. Decision Support Systems, 47(4), 547–553. https://doi.org/10.1016/j.dss.2009.05.016
Cortez, P., Cerdeira, A., Almeida, F., Matos, T., & Reis, J. (2009b). Wine Quality [Data set]. UCI Machine Learning Repository. https://doi.org/10.24432/C56S3T
Cover, T. M., & Hart, P. E. (1967). Nearest neighbor pattern classification. IEEE Transactions on Information Theory, 13(1), 21–27. https://doi.org/10.1109/TIT.1967.1053964
James, G., Witten, D., Hastie, T., & Tibshirani, R. (2021). An introduction to statistical learning: With applications in R (2nd ed.). Springer. https://doi.org/10.1007/978-1-0716-1418-1
Kuhn, M. (2008). Building predictive models in R using the caret package. Journal of Statistical Software, 28(5), 1–26. https://doi.org/10.18637/jss.v028.i05
Smola, A. J., & Schölkopf, B. (2004). A tutorial on support vector regression. Statistics and Computing, 14(3), 199–222. https://doi.org/10.1023/B:STCO.0000035301.49549.88
Wickham, H. (2016). ggplot2: Elegant graphics for data analysis. Springer. https://doi.org/10.1007/978-3-319-24277-4