P10 — Distance-Based and Margin/Kernel-Based Learning

Konsep Dasar Distance-Based dan Support Vector Learning

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.

Representasi Data

Misalkan tersedia \(n\) observasi dengan \(p\) prediktor yang dinyatakan sebagai:

\[\mathcal{D} = \left\{ (\mathbf{x}_i,y_i) \right\}_{i=1}^{n}\]

dengan:

  • \(\mathbf{x}_i=(x_{i1},x_{i2},\ldots,x_{ip})^\top\) merupakan vektor prediktor observasi ke-\(i\);
  • \(y_i\) merupakan nilai respons observasi ke-\(i\);
  • \(n\) merupakan jumlah observasi;
  • \(p\) merupakan jumlah prediktor.

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 (KNN)

Konsep Dasar KNN

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:

  • Menentukan jumlah tetangga \(K\).
  • Menghitung jarak observasi baru terhadap setiap observasi data latih.
  • Mengurutkan observasi berdasarkan jarak.
  • Memilih \(K\) observasi terdekat.
  • Menghasilkan prediksi berdasarkan respons tetangga terpilih.
NotePlaceholder Gambar 1 — Cara Kerja KNN

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.

Pengukuran Jarak Antarobservasi

Pemilihan tetangga merupakan komponen utama KNN. Oleh karena itu, ukuran jarak menentukan observasi mana yang dianggap paling dekat.

Euclidean Distance

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.

Manhattan Distance

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}\]

Minkowski Distance

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.

KNN untuk Klasifikasi

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.

KNN untuk Regresi

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.

Weighted KNN

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.

Pengaruh Jumlah Tetangga

Jumlah tetangga \(K\) menentukan tingkat fleksibilitas model KNN.

NotePlaceholder Gambar 2 — Pengaruh Nilai K

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:

  • \(K\) kecil cenderung menghasilkan bias lebih rendah dan varians lebih tinggi.
  • \(K\) besar cenderung menghasilkan bias lebih tinggi dan varians lebih rendah.

Hubungan tersebut menunjukkan adanya pertukaran antara bias dan varians (bias-variance trade-off).

NotePlaceholder Gambar 3 — Training Error dan Test Error pada KNN

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.

Keterbatasan KNN

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 untuk Klasifikasi

Konsep Dasar SVM

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.

NotePlaceholder Gambar 4 — Hyperplane, Margin, dan 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:

  1. Garis penuh merupakan hyperplane pemisah.

  2. Dua garis putus-putus merupakan batas margin.

  3. Titik yang berada tepat pada batas margin merupakan support vectors.

  4. 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.

Formulasi Hyperplane

Untuk \(p\) prediktor, fungsi keputusan linear dinyatakan sebagai:

\[f(\mathbf{x}) = \mathbf{w}^{\top}\mathbf{x}+b\]

dengan:

  • \(\mathbf{w}=(w_1,w_2,\ldots,w_p)^\top\) merupakan vektor bobot;
  • \(\mathbf{x}\) merupakan vektor prediktor;
  • \(b\) merupakan intersep.

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

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.

Soft-Margin SVM

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.

  • Nilai \(C\) besar memberikan penalti lebih tinggi terhadap pelanggaran margin.
  • Nilai \(C\) kecil memberikan toleransi lebih besar terhadap pelanggaran margin.

Dengan demikian, pemilihan \(C\) memengaruhi keseimbangan antara kompleksitas fungsi keputusan dan kesalahan klasifikasi.

Kernel dalam SVM

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:

Linear Kernel

\[K(\mathbf{x}_i,\mathbf{x}_j) = \mathbf{x}_i^\top\mathbf{x}_j\]

Polynomial Kernel

\[K(\mathbf{x}_i,\mathbf{x}_j) = \left( \gamma\mathbf{x}_i^\top\mathbf{x}_j+r \right)^d\]

Radial Basis Function Kernel

\[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 (SVR)

Konsep Dasar SVR

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.

NotePlaceholder Gambar 5 — Epsilon-Insensitive Tube pada SVR

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.

Epsilon-Insensitive Loss

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\).

Formulasi Optimasi SVR

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:

  • \(\frac12\|\mathbf{w}\|^2\) mengendalikan kompleksitas fungsi regresi;
  • \(C\) menentukan penalti kesalahan di luar epsilon-tube;
  • \(\varepsilon\) menentukan lebar wilayah toleransi;
  • \(\xi_i\) dan \(\xi_i^*\) menyatakan besarnya pelanggaran pada kedua sisi tube.

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.

Kernel dalam SVR

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.

Representasi Prediktor dan Keterbatasan Metode

Pengaruh Skala Prediktor

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.

Prediktor Kategorik

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.

Curse of Dimensionality

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.

Validitas Pembelajaran

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.

Ringkasan Metode

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.

Persiapan Package

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 yang Digunakan

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

Instalasi package hanya perlu dilakukan satu kali pada komputer yang digunakan. Jika package sudah tersedia, tahap instalasi dapat dilewati.

Show Code
# 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.

Memanggil Package

Setelah instalasi selesai, package dipanggil menggunakan fungsi library() agar fungsi-fungsi yang diperlukan tersedia selama praktikum.

Show Code
# 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
Show Code
# 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()
Show Code
# 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
Show Code
# Package untuk penyajian tabel
library(knitr)

Penggunaan Package pada Setiap Metode

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.

Catatan Penggunaan

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

Deskripsi Data

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.

Identifikasi Struktur Data

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.

Show Code
# 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().

Show Code
# Memeriksa dimensi data
dim(wine_data)
[1] 6497   13
Show Code
# 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"             
Show Code
# 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

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.

Show Code
# 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"
)
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.

Distribusi Variabel Respons

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.

Show Code
# 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"
)
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.

Show Code
# 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

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.

Show Code
# 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"
)
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.

Show Code
# 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"
)
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\).

Show Code
# 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"
)
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.

Show Code
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")
  )

Boxplot variabel fisikokimia anggur

Persiapan Data

Penentuan Variabel Respons

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.

Show Code
# 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"
)
Distribusi kategori kualitas anggur
quality_class frekuensi persentase
Not Good 2384 36.69
Good 4113 63.31
Show Code
# Memastikan variabel respons regresi tetap numerik
class(wine_data$quality)
[1] "numeric"

Penanganan Baris Identik

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.

Show Code
# 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"
)
Jumlah pengamatan sebelum dan setelah penghapusan baris identik
tahap jumlah_observasi
Sebelum penghapusan 6497
Setelah penghapusan 5320
Show Code
# 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"
  )
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.

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.

Show Code
# 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"
)
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

Pengolahan Prediktor

Selanjutnya, kita perlu menyiapkan prediktor untuk KNN dan SVM.

Ada dua proses utama:

  1. Pengkodean kategori: Variabel type diubah menjadi variabel numerik menggunakan dummy encoding.

  2. 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.

Show Code
# 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"
)
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.

KNN Classification

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:

  1. Menguji nilai (k) ganjil dari 3 sampai 25 untuk mengurangi kemungkinan hasil suara yang sama (tie) pada klasifikasi biner.
  2. Menggunakan 5-fold cross-validation pada data latih untuk mengevaluasi kinerja model.
  3. Memilih nilai (k) yang menghasilkan rata-rata balanced accuracy tertinggi.

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.

Show Code
# 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
Show Code
# 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"
)
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

Show Code
# 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)

Balanced accuracy KNN berdasarkan nilai k
Show Code
# Nilai k terbaik
model_knn$bestTune

Balanced 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.

Prediksi dan Evaluasi pada Data Uji

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.

Show Code
# 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"
)
Matriks konfusi KNN pada data uji
Not Good Good
Not Good 225 97
Good 173 570
Show Code
# 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"
)
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
ImportantPenting

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

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:

  • (()): prediksi skor kualitas untuk pengamatan ().
  • (N_k()): himpunan (k) tetangga terdekat dari ().
  • (y_i): skor kualitas pengamatan tetangga ke-(i).
  • (k): jumlah tetangga yang digunakan.

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.

Show Code
# 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"
)
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

Show Code
# 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)

RMSE KNN Regression berdasarkan nilai k
Show Code
# Menampilkan nilai k terbaik
model_knn_reg$bestTune

RMSE 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.

Prediksi dan Evaluasi pada Data Uji

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.

Show Code
# 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"
)
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

Show Code
# 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)

Perbandingan skor kualitas aktual dan prediksi KNN Regression
NoteCatatan Metodologis

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.

SVM Classification

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:

  • (K(_i,_j)): nilai kemiripan antara dua pengamatan berdasarkan kernel RBF.
  • (_i) dan (_j): vektor prediktor dari dua pengamatan.
  • (): parameter yang mengatur seberapa cepat kemiripan menurun ketika jarak antarpengamatan meningkat.

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.

Show Code
# 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"
)
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

Show Code
# 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)

Balanced accuracy SVM untuk berbagai kombinasi parameter
Show Code
# Menampilkan parameter terbaik
model_svm$bestTune

Balanced 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.

Prediksi dan Evaluasi pada Data Uji

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.

Show Code
# 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"
)
Matriks konfusi SVM pada data uji
Not Good Good
Not Good 257 108
Good 141 559
Show Code
# 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"
)
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

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:

  • (y_i): skor kualitas aktual pengamatan ke-(i).
  • (_i): skor kualitas hasil prediksi.
  • (): batas toleransi kesalahan prediksi.
  • (L_{}): besarnya kesalahan yang dikenai penalti.

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.

Show Code
# 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"
)
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

Show Code
# 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)

RMSE SVR untuk berbagai kombinasi parameter
Show Code
# Menampilkan parameter terbaik
model_svr$bestTune

RMSE 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.

Prediksi dan Evaluasi pada 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.

Show Code
# 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"
)
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

Show Code
# 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)

Perbandingan skor kualitas aktual dan prediksi SVR

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.

Evaluasi dan Perbandingan Model

Perbandingan Model Klasifikasi

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.

Show Code
# 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"
  )
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

Show Code
# 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 kinerja KNN dan SVM Classification

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.

Perbandingan Model Regresi

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.

Show Code
# 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"
  )
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

Show Code
# 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)

Perbandingan kesalahan prediksi KNN Regression dan SVR

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.

Ringkasan Hasil Implementasi

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.

Daftar Pustaka

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