Menerapkan Rasa SVM Lain dengan Python's Scikit-Learn

Pengantar

Panduan ini adalah bagian ketiga dan terakhir dari tiga panduan tentang Support Vector Machines (SVM). Dalam panduan ini, kami akan terus bekerja dengan kasus penggunaan uang kertas palsu, memiliki rekap cepat tentang ide umum di balik SVM, memahami apa trik kernel, dan mengimplementasikan berbagai jenis kernel non-linear dengan Scikit-Learn.

Dalam rangkaian lengkap panduan SVM, selain belajar tentang jenis SVM lainnya, Anda juga akan belajar tentang SVM sederhana, parameter pra-definisi SVM, hyperparameter C dan Gamma dan bagaimana mereka dapat disesuaikan dengan pencarian grid dan validasi silang.

Jika Anda ingin membaca panduan sebelumnya, Anda dapat melihat dua panduan pertama atau melihat topik mana yang paling Anda minati. Di bawah ini adalah tabel topik yang dibahas dalam setiap panduan:

1. Menerapkan SVM dan Kernel SVM dengan Python's Scikit-Learn

• Kasus penggunaan: lupakan uang kertas
• Latar belakang SVM
• Model SVM Sederhana (Linear).
  • Tentang Kumpulan Data
  • Mengimpor Kumpulan Data
  • Menjelajahi Kumpulan Data
• Menerapkan SVM dengan Scikit-Learn
  • Membagi Data ke dalam Train/Test Sets
  • Melatih Model
  • Membuat Prediksi
  • Mengevaluasi Model
  • Menafsirkan Hasil

2. Memahami SVM Hyperparameter

• Hiperparameter C
• Hiperparameter Gamma

3. Mengimplementasikan rasa SVM lainnya dengan Python's Scikit-Learn

• Ide Umum SVM (rekap)
• Kernel (Trik) SVM
• Menerapkan SVM Kernel Non-Linear dengan Scikit-Learn
• Mengimpor Perpustakaan
  • Mengimpor Kumpulan Data
  • Membagi Data Menjadi Fitur (X) dan Target (y)
  • Membagi Data Ke Dalam Train/Test Sets
  • Melatih Algoritma
• Kernel polinomial
  • Membuat Prediksi
  • Mengevaluasi Algoritma
• Kernel Gaussian
  • Prediksi dan Evaluasi
• Kernel Sigmoid
  • Prediksi dan Evaluasi
• Perbandingan Kinerja Kernel Non-Linear

Mari kita ingat apa itu SVM sebelum melihat beberapa variasi kernel SVM yang menarik.

Ide Umum SVM

Dalam kasus data yang dapat dipisahkan secara linear dalam dua dimensi (seperti yang ditunjukkan pada Gambar 1), pendekatan algoritme pembelajaran mesin tipikal adalah mencoba menemukan batas yang membagi data sedemikian rupa sehingga kesalahan klasifikasi yang salah diminimalkan. Jika Anda melihat lebih dekat pada gambar 1, perhatikan mungkin ada beberapa batas (tak terhingga) yang membagi titik-titik data dengan benar. Dua garis putus-putus serta garis penuh adalah klasifikasi data yang valid.

Gambar 1: Beberapa Batasan Keputusan

Ketika SVM memilih batas keputusan, ia memilih batas yang memaksimalkan jarak antara dirinya dan titik data terdekat dari kelas. Kita sudah tahu bahwa titik data terdekat adalah vektor pendukung dan jarak dapat diparametrikan keduanya C dan gamma hiperparameter.

Dalam menghitung batas keputusan tersebut, algoritme memilih berapa banyak poin untuk dipertimbangkan dan seberapa jauh margin dapat digunakan – ini mengonfigurasi masalah maksimalisasi margin. Dalam menyelesaikan masalah maksimalisasi margin, SVM menggunakan vektor pendukung (seperti yang terlihat pada Gambar 2) dan mencoba mencari tahu nilai optimal apa yang menjaga jarak margin lebih besar, sambil mengklasifikasikan lebih banyak poin dengan benar sesuai dengan fungsi yang digunakan. pisahkan datanya.

Gambar 2: Batas Keputusan dengan Vektor Pendukung

Inilah mengapa SVM berbeda dari algoritma klasifikasi lainnya, setelah tidak hanya menemukan batas keputusan, tetapi akhirnya menemukan batas keputusan yang optimal.

Ada matematika kompleks yang berasal dari statistik dan metode komputasi yang terlibat di balik pencarian vektor pendukung, menghitung margin antara batas keputusan dan vektor dukungan, dan memaksimalkan margin itu. Kali ini, kita tidak akan masuk ke detail bagaimana matematika dimainkan.

Itu selalu penting untuk menyelam lebih dalam dan memastikan algoritme pembelajaran mesin bukanlah semacam mantra misterius, meskipun tidak mengetahui setiap detail matematika saat ini tidak dan tidak akan menghentikan Anda untuk dapat mengeksekusi algoritme dan mendapatkan hasil.

Kernel (Trik) SVM

Pada bagian sebelumnya, kita telah mengingat dan mengatur ide umum SVM – melihat bagaimana hal itu dapat digunakan untuk menemukan batas keputusan yang optimal untuk data yang dapat dipisahkan secara linear. Namun, dalam kasus data yang tidak dapat dipisahkan secara linier, seperti yang ditunjukkan pada Gambar 3, kita telah mengetahui bahwa garis lurus tidak dapat digunakan sebagai batas keputusan.

Gambar 3: Data yang Dapat Dipisahkan Non-linear

Sebaliknya, kita dapat menggunakan SVM versi modifikasi yang telah kita bahas di awal, yang disebut Kernel SVM.

Pada dasarnya, apa yang akan dilakukan oleh kernel SVM adalah memproyeksikan data yang tidak dapat dipisahkan secara linier dari dimensi yang lebih rendah ke bentuk yang sesuai di dimensi yang lebih tinggi. Ini adalah tipuan, karena saat memproyeksikan data yang dapat dipisahkan secara nonlinier dalam dimensi yang lebih tinggi, bentuk data berubah sedemikian rupa sehingga menjadi dapat dipisahkan. Misalnya, ketika memikirkan tentang 3 dimensi, titik data dari setiap kelas dapat dialokasikan dalam dimensi yang berbeda, membuatnya dapat dipisahkan. Salah satu cara untuk meningkatkan dimensi data dapat dilakukan dengan mengeksponensialkannya. Sekali lagi, ada matematika kompleks yang terlibat dalam hal ini, tetapi Anda tidak perlu khawatir untuk menggunakan SVM. Sebaliknya, kita dapat menggunakan pustaka Scikit-Learn Python untuk mengimplementasikan dan menggunakan kernel non-linear dengan cara yang sama seperti kita menggunakan linear.

Menerapkan SVM Kernel Non-Linear dengan Scikit-Learn

Pada bagian ini, kita akan menggunakan kumpulan data yang sama untuk memprediksi apakah uang kertas itu asli atau palsu berdasarkan empat fitur yang sudah kita ketahui.

Anda akan melihat bahwa langkah-langkah selanjutnya adalah langkah-langkah pembelajaran mesin biasa dan hanya membutuhkan sedikit penjelasan sampai kita mencapai bagian di mana kita melatih SVM Kernel Non-linear kita.

Mengimpor Perpustakaan

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split

Mengimpor Kumpulan Data

data_link = "https://archive.ics.uci.edu/ml/machine-learning-databases/00267/data_banknote_authentication.txt"
col_names = ["variance", "skewness", "curtosis", "entropy", "class"] bankdata = pd.read_csv(data_link, names=col_names, sep=",", header=None)
bankdata.head()mes)

Membagi Data Menjadi Fitur (X) dan Target (y)

X = bankdata.drop('class', axis=1)
y = bankdata['class']

Membagi Data ke dalam Train/Test Sets

SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

Melatih Algoritma

Untuk melatih SVM kernel, kami akan menggunakan yang sama SVC kelas Scikit-Learn svm perpustakaan. Perbedaannya terletak pada nilai parameter kernel dari SVC kelas.

Dalam kasus SVM sederhana kami telah menggunakan "linier" sebagai nilai untuk parameter kernel. Namun, seperti yang telah kami sebutkan sebelumnya, untuk kernel SVM, kami dapat menggunakan kernel Gaussian, polinomial, sigmoid, atau yang dapat dihitung. Kami akan menerapkan kernel polinomial, Gaussian, dan sigmoid dan melihat metrik terakhirnya untuk melihat mana yang cocok dengan kelas kami dengan metrik yang lebih tinggi.

1. Kernel polinomial

Dalam aljabar, polinomial adalah ekspresi dari bentuk:

$$
2a*b^3 + 4a – 9
$$

Ini memiliki variabel, seperti a dan b, konstanta, dalam contoh kita, 9 dan koefisien (konstanta yang disertai dengan variabel), seperti 2 dan 4. itu 3 dianggap sebagai derajat polinomial.

Ada jenis data yang paling baik dijelaskan saat menggunakan fungsi polinomial, di sini, yang akan dilakukan kernel adalah memetakan data kita ke polinomial yang akan kita pilih derajatnya. Semakin tinggi derajatnya, semakin banyak fungsi akan mencoba mendekati data, sehingga batas keputusan lebih fleksibel (dan lebih cenderung overfit) – semakin rendah derajatnya, semakin tidak fleksibel.

Jadi, untuk mengimplementasikan kernel polinomial, selain memilih poly kernel, kami juga akan memberikan nilai untuk degree parameter dari SVC kelas. Di bawah ini adalah kodenya:

from sklearn.svm import SVC
svc_poly = SVC(kernel='poly', degree=8)
svc_poly.fit(X_train, y_train)

Membuat Prediksi

Sekarang, setelah kami melatih algoritme, langkah selanjutnya adalah membuat prediksi pada data uji.

Seperti yang telah kita lakukan sebelumnya, kita dapat menjalankan skrip berikut untuk melakukannya:

y_pred_poly = svclassifier.predict(X_test)

Mengevaluasi Algoritma

Seperti biasa, langkah terakhir adalah melakukan evaluasi pada kernel polinomial. Karena kita telah mengulangi kode untuk laporan klasifikasi dan matriks konfusi beberapa kali, mari ubah menjadi fungsi itu display_results setelah menerima yang bersangkutan y_test, y_pred dan judul matriks kebingungan Seaborn dengan cm_title:

def display_results(y_test, y_pred, cm_title): cm = confusion_matrix(y_test,y_pred) sns.heatmap(cm, annot=True, fmt='d').set_title(cm_title) print(classification_report(y_test,y_pred))

Sekarang, kita dapat memanggil fungsi tersebut dan melihat hasil yang diperoleh dengan kernel polinomial:

cm_title_poly = "Confusion matrix with polynomial kernel"
display_results(y_test, y_pred_poly, cm_title_poly)

Outputnya terlihat seperti ini:

 precision recall f1-score support 0 0.69 1.00 0.81 148 1 1.00 0.46 0.63 127 accuracy 0.75 275 macro avg 0.84 0.73 0.72 275
weighted avg 0.83 0.75 0.73 275

Sekarang kita dapat mengulangi langkah yang sama untuk kernel Gaussian dan sigmoid.

2. Kernel Gaussian

Untuk menggunakan kernel gaussian, kita hanya perlu menentukan 'rbf' sebagai nilai untuk kernel parameter kelas SVC:

svc_gaussian = SVC(kernel='rbf', degree=8)
svc_gaussian.fit(X_train, y_train)

Saat menjelajahi kernel ini lebih jauh, Anda juga dapat menggunakan pencarian grid untuk menggabungkannya dengan yang berbeda C dan gamma nilai-nilai.

Prediksi dan Evaluasi

y_pred_gaussian = svc_gaussian.predict(X_test)

cm_title_gaussian = "Confusion matrix with Gaussian kernel"
display_results(y_test, y_pred_gaussian, cm_title_gaussian)

Output dari SVM kernel Gaussian terlihat seperti ini:

 precision recall f1-score support 0 1.00 1.00 1.00 148 1 1.00 1.00 1.00 127 accuracy 1.00 275 macro avg 1.00 1.00 1.00 275
weighted avg 1.00 1.00 1.00 275

3. Kernel Sigmoid

Terakhir, mari gunakan kernel sigmoid untuk mengimplementasikan Kernel SVM. Lihatlah skrip berikut:

svc_sigmoid = SVC(kernel='sigmoid')
svc_sigmoid.fit(X_train, y_train)

Untuk menggunakan kernel sigmoid, Anda harus menentukan 'sigmoid' sebagai nilai untuk kernel parameter dari SVC kelas.

Prediksi dan Evaluasi

y_pred_sigmoid = svc_sigmoid.predict(X_test)

cm_title_sigmoid = "Confusion matrix with Sigmoid kernel"
display_results(y_test, y_pred_sigmoid, cm_title_sigmoid)

Output dari Kernel SVM dengan kernel Sigmoid terlihat seperti ini:

 precision recall f1-score support 0 0.67 0.71 0.69 148 1 0.64 0.59 0.61 127 accuracy 0.65 275 macro avg 0.65 0.65 0.65 275
weighted avg 0.65 0.65 0.65 275

Perbandingan Kinerja Kernel Non-Linear

Jika kita secara singkat membandingkan kinerja berbagai jenis kernel non-linear, mungkin terlihat bahwa kernel sigmoid memiliki metrik terendah, sehingga kinerjanya terburuk.

Di antara kernel Gaussian dan polinomial, kita dapat melihat bahwa kernel Gaussian mencapai tingkat prediksi 100% yang sempurna – yang biasanya mencurigakan dan mungkin mengindikasikan overfit, sedangkan kernel polinomial salah mengklasifikasikan 68 instance kelas 1.

Oleh karena itu, tidak ada aturan keras dan cepat mengenai kernel mana yang berkinerja terbaik di setiap skenario atau dalam skenario kami saat ini tanpa mencari hyperparameter lebih lanjut, memahami tentang setiap bentuk fungsi, menjelajahi data, dan membandingkan hasil pelatihan dan pengujian untuk melihat apakah algoritme sedang menggeneralisasi.

Ini semua tentang menguji semua kernel dan memilih satu dengan kombinasi parameter dan persiapan data yang memberikan hasil yang diharapkan sesuai dengan konteks proyek Anda.

Melangkah Lebih Jauh – Proyek end-to-end genggam

Sifat ingin tahu Anda membuat Anda ingin melangkah lebih jauh? Kami merekomendasikan untuk memeriksa kami Proyek Terpandu: “Prediksi Harga Rumah Langsung – Pembelajaran Mesin dengan Python”.

Dalam proyek terpandu ini – Anda akan mempelajari cara membuat model pembelajaran mesin tradisional yang kuat serta model pembelajaran mendalam, memanfaatkan Ensemble Learning dan melatih meta-pelajar untuk memprediksi harga rumah dari sekumpulan model Scikit-Learn dan Keras.

Menggunakan Keras, API pembelajaran mendalam yang dibangun di atas Tensorflow, kami akan bereksperimen dengan arsitektur, membangun ensembel model bertumpuk, dan melatih meta-pelajar jaringan saraf (model level-1) untuk mengetahui harga rumah.

Pembelajaran mendalam itu luar biasa – tetapi sebelum beralih ke itu, disarankan untuk juga mencoba memecahkan masalah dengan teknik yang lebih sederhana, seperti dengan pembelajaran dangkal algoritma. Kinerja dasar kami akan didasarkan pada a Regresi Hutan Acak algoritma. Selain itu – kami akan mengeksplorasi pembuatan ansambel model melalui Scikit-Learn melalui teknik seperti mengantongi dan pemungutan suara.

Ini adalah proyek end-to-end, dan seperti semua proyek Machine Learning, kami akan memulai dengan – dengan Analisis Data Eksplorasi, Diikuti oleh Pengolah Data dan akhirnya Bangunan Dangkal dan Model Pembelajaran Mendalam agar sesuai dengan data yang telah kita jelajahi dan bersihkan sebelumnya.

Kesimpulan

Pada artikel ini kami membuat rekap singkat tentang SVM, mempelajari tentang trik kernel dan menerapkan rasa yang berbeda dari SVM non-linear.

Saya sarankan Anda mengimplementasikan setiap kernel dan terus melangkah lebih jauh. Anda dapat menjelajahi matematika yang digunakan untuk membuat masing-masing kernel yang berbeda, mengapa mereka dibuat dan perbedaan terkait hyperparameternya. Dengan begitu, Anda akan belajar tentang teknik dan jenis kernel apa yang terbaik untuk diterapkan tergantung pada konteks dan data yang tersedia.

Memiliki pemahaman yang jelas tentang cara kerja setiap kernel dan kapan menggunakannya pasti akan membantu Anda dalam perjalanan Anda. Beri tahu kami bagaimana kemajuannya dan selamat membuat kode!

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• Platoblockchain. Intelijen Metaverse Web3. Pengetahuan Diperkuat. Akses Di Sini.
• Mencetak Masa Depan bersama Adryenn Ashley. Akses Di Sini.
• Sumber: https://stackabuse.com/implementing-other-svm-flavors-with-pythons-scikit-learn/