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

Pengantar

Panduan ini adalah bagian pertama dari tiga panduan tentang Support Vector Machines (SVM). Dalam seri ini, kita akan mengerjakan kasus penggunaan uang kertas palsu, belajar tentang SVM sederhana, lalu tentang hiperparameter SVM, dan terakhir, mempelajari konsep yang disebut trik kernel dan jelajahi jenis SVM lainnya.

Jika Anda ingin membaca semua panduan atau melihat mana yang paling menarik bagi Anda, di bawah ini adalah tabel topik yang tercakup dalam setiap panduan:

1. Mengimplementasikan 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 Hyperparameter SVM (segera akan datang!)

• Hiperparameter C
• Hiperparameter Gamma

3. Mengimplementasikan rasa SVM lainnya dengan Python's Scikit-Learn (segera akan datang!)

• 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

Kasus Penggunaan: Uang Kertas Palsu

Terkadang orang menemukan cara untuk memalsukan uang kertas. Jika ada orang yang melihat catatan itu dan memverifikasi validitasnya, mungkin sulit untuk ditipu olehnya.

Tapi apa yang terjadi jika tidak ada orang yang melihat setiap catatan? Apakah ada cara untuk mengetahui secara otomatis apakah uang kertas itu palsu atau asli?

Ada banyak cara untuk menjawab pertanyaan-pertanyaan itu. Salah satu jawabannya adalah memotret setiap uang kertas yang diterima, membandingkan gambarnya dengan gambar uang palsu, dan kemudian mengklasifikasikannya sebagai asli atau palsu. Setelah mungkin membosankan atau kritis untuk menunggu validasi catatan, menarik juga untuk melakukan perbandingan itu dengan cepat.

Karena gambar digunakan, mereka dapat dipadatkan, direduksi menjadi skala abu-abu, dan pengukurannya diekstraksi atau dikuantisasi. Dengan cara ini, perbandingannya adalah antara pengukuran gambar, bukan setiap piksel gambar.

Sejauh ini, kami telah menemukan cara untuk memproses dan membandingkan uang kertas, tetapi bagaimana mereka akan diklasifikasikan menjadi asli atau palsu? Kita dapat menggunakan pembelajaran mesin untuk melakukan klasifikasi itu. Ada algoritma klasifikasi yang disebut Mendukung Mesin Vektor, terutama dikenal dengan bentuk singkatannya: svm.

Latar belakang SVM

SVM awalnya diperkenalkan pada tahun 1968, oleh Vladmir Vapnik dan Alexey Chervonenkis. Saat itu, algoritme mereka terbatas pada klasifikasi data yang dapat dipisahkan hanya menggunakan satu garis lurus, atau data yang terpisah dapat dipisahkan secara linier. Kita bisa melihat seperti apa pemisahan itu:

Pada gambar di atas kita memiliki garis di tengah, dimana beberapa titik di sebelah kiri, dan yang lainnya di sebelah kanan garis itu. Perhatikan bahwa kedua kelompok titik dipisahkan dengan sempurna, tidak ada titik di antara atau bahkan di dekat garis. Tampaknya ada batas antara titik-titik yang serupa dan garis yang membaginya, batas itu disebut margin pemisahan. Fungsi batas pemisah adalah untuk membuat jarak antara titik-titik yang sama dan garis yang membaginya menjadi lebih besar. SVM melakukannya dengan menggunakan beberapa titik dan menghitung vektor tegak lurusnya untuk mendukung keputusan margin garis. Itu adalah mendukung vektor yang merupakan bagian dari nama algoritma. Kami akan mengerti lebih banyak tentang mereka nanti. Dan garis lurus yang kita lihat di tengah ditemukan oleh metode itu memaksimalkan ruang antara garis dan titik, atau yang memaksimalkan margin pemisahan. Metode tersebut berasal dari bidang Teori Optimasi.

Dalam contoh yang baru saja kita lihat, kedua kelompok titik dapat dengan mudah dipisahkan, karena setiap titik individu berdekatan dengan titik yang serupa, dan kedua kelompok tersebut saling berjauhan.

Namun apa yang terjadi jika tidak ada cara untuk memisahkan data menggunakan satu garis lurus? Jika ada titik yang tidak pada tempatnya, atau jika diperlukan kurva?

Untuk mengatasi masalah tersebut, SVM kemudian disempurnakan pada tahun 1990-an untuk dapat juga mengklasifikasikan data yang memiliki titik-titik yang jauh dari kecenderungan sentralnya, seperti outlier, atau masalah yang lebih kompleks yang memiliki lebih dari dua dimensi dan tidak dapat dipisahkan secara linier. .

Yang menarik adalah bahwa hanya dalam beberapa tahun terakhir SVM diadopsi secara luas, terutama karena kemampuan mereka untuk mencapai kadang-kadang lebih dari 90% jawaban yang benar atau ketepatan, untuk masalah yang sulit.

SVM diimplementasikan dengan cara yang unik jika dibandingkan dengan algoritme pembelajaran mesin lainnya, setelah didasarkan pada penjelasan statistik tentang apa itu pembelajaran, atau pada Teori Belajar Statistik.

Pada artikel ini, kita akan melihat apa itu algoritme Support Vector Machines, teori singkat di balik mesin vektor dukungan, dan penerapannya di pustaka Scikit-Learn Python. Kami kemudian akan beralih ke konsep SVM lain, yang dikenal sebagai SVM Kernel, atau Trik kernel, dan juga akan mengimplementasikannya dengan bantuan Scikit-Learn.

Model SVM Sederhana (Linear).

Tentang Kumpulan Data

Mengikuti contoh yang diberikan pada pendahuluan, kita akan menggunakan dataset yang memiliki pengukuran gambar uang kertas asli dan palsu.

Saat melihat dua nada, mata kita biasanya mengamatinya dari kiri ke kanan dan memeriksa di mana mungkin ada kesamaan atau perbedaan. Kami mencari titik hitam yang muncul sebelum titik hijau, atau tanda mengkilap yang berada di atas ilustrasi. Artinya ada urutan dimana kita melihat not tersebut. Jika kita tahu ada titik hijau dan titik hitam, tetapi tidak jika titik hijau muncul sebelum hitam, atau jika hitam muncul sebelum hijau, akan lebih sulit membedakan nada.

Ada metode serupa dengan apa yang baru saja kami jelaskan yang dapat diterapkan pada gambar uang kertas. Secara umum, metode ini terdiri dari menerjemahkan piksel gambar menjadi sinyal, kemudian mempertimbangkan urutan di mana setiap sinyal yang berbeda terjadi pada gambar dengan mengubahnya menjadi gelombang kecil, atau gelombang kecil. Setelah mendapatkan wavelet, ada cara untuk mengetahui urutan di mana beberapa sinyal terjadi sebelum yang lain, atau waktu, tapi tidak persis sinyal apa. Untuk mengetahuinya, frekuensi gambar perlu diperoleh. Mereka diperoleh dengan metode yang melakukan dekomposisi setiap sinyal, yang disebut Metode Fourier.

Setelah dimensi waktu diperoleh melalui wavelet, dan dimensi frekuensi melalui metode Fourier, dilakukan superimposisi waktu dan frekuensi untuk melihat apakah keduanya memiliki kecocokan, inilah lilitan analisis. Konvolusi mendapatkan kecocokan yang cocok dengan gelombang kecil dengan frekuensi gambar dan mengetahui frekuensi mana yang lebih menonjol.

Metode yang melibatkan pencarian wavelet, frekuensinya, dan kemudian mencocokkan keduanya, disebut Transformasi gelombang. Transformasi wavelet memiliki koefisien, dan koefisien tersebut digunakan untuk memperoleh pengukuran yang kita miliki dalam dataset.

Mengimpor Kumpulan Data

Dataset uang kertas yang akan kita gunakan di bagian ini sama dengan yang digunakan di bagian klasifikasi tutorial pohon keputusan.

Mari mengimpor data ke dalam panda dataframe struktur, dan lihat lima baris pertamanya dengan head() Metode.

Perhatikan bahwa data disimpan dalam a txt (teks) format file, dipisahkan dengan koma, dan tanpa header. Kita dapat merekonstruksinya sebagai tabel dengan membacanya sebagai a csv, menentukan separator sebagai koma, dan menambahkan nama kolom dengan names argumen.

Mari ikuti ketiga langkah tersebut sekaligus, lalu lihat lima baris pertama dari data tersebut:

import pandas as pd 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()

Ini menghasilkan:

	variance skewness curtosis entropy class
0 3.62160 8.6661 -2.8073 -0.44699 0
1 4.54590 8.1674 -2.4586 -1.46210 0
2 3.86600 -2.6383 1.9242 0.10645 0
3 3.45660 9.5228 -4.0112 -3.59440 0
4 0.32924 -4.4552 4.5718 -0.98880 0

Kita dapat melihat bahwa ada lima kolom dalam kumpulan data kita, yaitu, variance, skewness, curtosis, entropy, dan class. Pada lima baris, empat kolom pertama diisi dengan angka seperti 3.62160, 8.6661, -2.8073 atau kontinu nilai, dan yang terakhir class kolom memiliki lima baris pertamanya diisi dengan 0s, atau a berlainan nilai.

Karena tujuan kami adalah untuk memprediksi apakah uang kertas bank asli atau tidak, kami dapat melakukannya berdasarkan empat atribut uang kertas:

• variance dari gambar Transformasi Wavelet. Umumnya, varian adalah nilai kontinu yang mengukur seberapa dekat atau jauh titik data dengan nilai rata-rata data. Jika titik lebih dekat dengan nilai rata-rata data, distribusinya lebih dekat ke distribusi normal, yang biasanya berarti nilainya lebih terdistribusi dengan baik dan agak lebih mudah diprediksi. Dalam konteks gambar saat ini, ini adalah varian dari koefisien yang dihasilkan dari transformasi wavelet. Semakin sedikit varians, semakin dekat koefisien untuk menerjemahkan gambar yang sebenarnya.

• skewness dari gambar Transformasi Wavelet. Kemiringan adalah nilai kontinu yang menunjukkan asimetri distribusi. Jika ada lebih banyak nilai di sebelah kiri rata-rata, distribusinya adalah miring secara negatif, jika ada lebih banyak nilai di sebelah kanan rata-rata, distribusinya adalah condong positif, dan jika rata-rata, modus, dan mediannya sama, distribusinya adalah simetris. Semakin simetris suatu distribusi, semakin dekat dengan distribusi normal, juga memiliki nilai yang lebih terdistribusi dengan baik. Dalam konteks sekarang, ini adalah kemiringan dari koefisien yang dihasilkan dari transformasi wavelet. Semakin simetris, semakin dekat koefisien kitavariance, skewness, curtosis, entropykembali untuk menerjemahkan gambar yang sebenarnya.

• curtosis (atau kurtosis) dari gambar Transformasi Wavelet. Kurtosis adalah nilai kontinu yang, seperti kecondongan, juga menggambarkan bentuk distribusi. Bergantung pada koefisien kurtosis (k), sebuah distribusi – bila dibandingkan dengan distribusi normal bisa lebih atau kurang rata – atau memiliki lebih banyak atau lebih sedikit data di ekstremitas atau ekornya. Ketika distribusi lebih tersebar dan lebih rata, itu disebut platikurtik; ketika kurang menyebar dan lebih terkonsentrasi di tengah, mesokurtik; dan ketika distribusi hampir seluruhnya terkonsentrasi di tengah, itu disebut leptokurtik. Ini adalah kasus yang sama dengan kasus varians dan skewness sebelumnya, semakin mesokurtik distribusinya, semakin dekat koefisien untuk menerjemahkan gambar yang sebenarnya.

• entropy gambar. Entropi juga merupakan nilai kontinu, biasanya mengukur keacakan atau ketidakteraturan dalam suatu sistem. Dalam konteks gambar, entropi mengukur perbedaan antara piksel dan piksel tetangganya. Untuk konteks kita, semakin banyak entropi yang dimiliki koefisien, semakin banyak kehilangan yang terjadi saat mengubah gambar – dan semakin kecil entropi, semakin kecil pula kehilangan informasi.

Variabel kelima adalah class variabel, yang mungkin memiliki nilai 0 dan 1, yang menyatakan apakah not itu asli atau palsu.

Kita dapat memeriksa apakah kolom kelima berisi nol dan satu dengan Pandas' unique() Metode:

bankdata['class'].unique()

Metode di atas mengembalikan:

array([0, 1]) 

Metode di atas mengembalikan array dengan nilai 0 dan 1. Ini berarti bahwa satu-satunya nilai yang terdapat dalam baris kelas kita adalah nol dan satu. Siap digunakan sebagai target dalam pembelajaran kami yang diawasi.

• class gambar. Ini adalah nilai integer, 0 saat gambar dipalsukan, dan 1 saat gambar nyata.

Karena kami memiliki kolom dengan anotasi gambar nyata dan lupa, ini berarti jenis pembelajaran kami adalah diawasi.

Kita juga bisa melihat berapa banyak record, atau gambar yang kita miliki, dengan melihat jumlah baris pada data melalui shape milik:

bankdata.shape

Output ini:

(1372, 5)

Baris di atas berarti terdapat 1,372 baris gambar uang kertas hasil transformasi, dan 5 kolom. Ini adalah data yang akan kami analisis.

Kami telah mengimpor kumpulan data kami dan melakukan beberapa pemeriksaan. Sekarang kita dapat menjelajahi data kita untuk memahaminya dengan lebih baik.

Menjelajahi Kumpulan Data

Kita baru saja melihat bahwa hanya ada nol dan satu di kolom kelas, tetapi kita juga dapat mengetahui berapa proporsinya – dengan kata lain – jika ada lebih banyak nol daripada satu, lebih banyak satu daripada nol, atau jika jumlah angka nol sama dengan angka satu, artinya ada seimbang.

Untuk mengetahui proporsi kita dapat menghitung masing-masing nilai nol dan satu dalam data value_counts() Metode:

bankdata['class'].value_counts()

Output ini:

0 762
1 610
Name: class, dtype: int64

Pada hasil di atas, kita dapat melihat bahwa terdapat 762 nol dan 610 nol, atau 152 lebih banyak nol daripada satu. Ini berarti bahwa kami memiliki sedikit lebih banyak pemalsuan gambar asli, dan jika perbedaan itu lebih besar, misalnya, 5500 nol dan 610 satu, itu dapat berdampak negatif pada hasil kami. Setelah kami mencoba menggunakan contoh-contoh itu dalam model kami - semakin banyak contoh, biasanya berarti semakin banyak informasi yang harus diputuskan oleh model antara catatan palsu atau nyata - jika hanya ada sedikit contoh catatan nyata, model cenderung menjadi keliru ketika mencoba untuk mengenali mereka.

Kita sudah tahu bahwa ada 152 catatan palsu lagi, tetapi bisakah kita yakin itu adalah contoh yang cukup untuk dipelajari oleh model? Mengetahui berapa banyak contoh yang dibutuhkan untuk belajar adalah pertanyaan yang sangat sulit untuk dijawab, sebagai gantinya, kita dapat mencoba untuk memahami, dalam persentase, seberapa besar perbedaan antar kelas.

Langkah pertama adalah menggunakan panda value_counts() metode lagi, tapi sekarang mari kita lihat persentase dengan memasukkan argumen normalize=True:

bankdata['class'].value_counts(normalize=True)

Grafik normalize=True menghitung persentase data untuk setiap kelas. Sejauh ini persentase data palsu (0) dan data asli (1) adalah:

0 0.555394
1 0.444606
Name: class, dtype: float64

Ini berarti sekitar (~) 56% dari kumpulan data kami dipalsukan dan 44% di antaranya asli. Ini memberi kami rasio 56% -44%, yang sama dengan perbedaan 12%. Perbedaan ini secara statistik dianggap kecil, karena hanya sedikit di atas 10%, sehingga data dianggap berimbang. Jika alih-alih proporsi 56:44, ada proporsi 80:20 atau 70:30, maka data kami akan dianggap tidak seimbang, dan kami perlu melakukan beberapa perlakuan ketidakseimbangan, tetapi, untungnya, tidak demikian.

Kita juga dapat melihat perbedaan ini secara visual, dengan melihat distribusi kelas atau target dengan histogram yang dijiwai Panda, dengan menggunakan:

bankdata['class'].plot.hist();

Ini memplot histogram menggunakan struktur kerangka data secara langsung, dikombinasikan dengan matplotlib perpustakaan yang berada di balik layar.

Dengan melihat histogram, kita dapat yakin bahwa nilai target kita adalah 0 atau 1 dan datanya seimbang.

Ini adalah analisis kolom yang kami coba prediksi, tetapi bagaimana dengan menganalisis kolom lain dari data kami?

Kita dapat melihat pengukuran statistik dengan describe() metode kerangka data. Kita juga bisa menggunakan .T of transpose – untuk membalikkan kolom dan baris, membuatnya lebih langsung untuk membandingkan seluruh nilai:

bankdata.describe().T

Ini menghasilkan:

 count mean std min 25% 50% 75% max
variance 1372.0 0.433735 2.842763 -7.0421 -1.773000 0.49618 2.821475 6.8248
skewness 1372.0 1.922353 5.869047 -13.7731 -1.708200 2.31965 6.814625 12.9516
curtosis 1372.0 1.397627 4.310030 -5.2861 -1.574975 0.61663 3.179250 17.9274
entropy 1372.0 -1.191657 2.101013 -8.5482 -2.413450 -0.58665 0.394810 2.4495
class 1372.0 0.444606 0.497103 0.0000 0.000000 0.00000 1.000000 1.0000

Perhatikan bahwa kolom skewness dan curtosis memiliki nilai rata-rata yang jauh dari nilai standar deviasi, hal ini menunjukkan bahwa nilai tersebut jauh dari tendensi sentral data, atau memiliki variabilitas yang lebih besar.

Kita juga dapat mengintip distribusi setiap fitur secara visual, dengan memplot histogram setiap fitur di dalam for loop. Selain melihat sebarannya, menarik juga untuk melihat bagaimana poin-poin dari masing-masing kelas dipisahkan terkait fitur masing-masing. Untuk melakukan itu, kita dapat memplot plot pencar yang membuat kombinasi fitur di antara mereka, dan menetapkan warna berbeda untuk setiap titik terkait dengan kelasnya.

Mari kita mulai dengan masing-masing distribusi fitur, dan plotkan histogram dari setiap kolom data kecuali untuk class kolom. Itu class kolom tidak akan dipertimbangkan oleh posisinya dalam larik kolom bankdata. Semua kolom akan dipilih kecuali yang terakhir dengan columns[:-1]:

import matplotlib.pyplot as plt for col in bankdata.columns[:-1]: plt.title(col) bankdata[col].plot.hist() plt.show();

Setelah menjalankan kode di atas, kita dapat melihat keduanya skewness dan entropy distribusi data condong negatif dan curtosis miring secara positif. Semua distribusi simetris, dan variance satu-satunya distribusi yang mendekati normal.

Kita sekarang dapat melanjutkan ke bagian kedua, dan memplot scatterplot dari setiap variabel. Untuk melakukan ini, kita juga bisa memilih semua kolom kecuali kelas, dengan columns[:-1], gunakan Seaborn scatterplot() dan dua for loop untuk mendapatkan variasi pairing untuk masing-masing fitur. Kami juga dapat mengecualikan pasangan fitur dengan dirinya sendiri, dengan menguji apakah fitur pertama sama dengan fitur kedua dengan an if statement.

import seaborn as sns for feature_1 in bankdata.columns[:-1]: for feature_2 in bankdata.columns[:-1]: if feature_1 != feature_2: print(feature_1, feature_2) sns.scatterplot(x=feature_1, y=feature_2, data=bankdata, hue='class') plt.show();

Perhatikan bahwa semua grafik memiliki titik data nyata dan palsu yang tidak terpisah dengan jelas satu sama lain, ini berarti ada semacam superposisi kelas. Karena model SVM menggunakan garis untuk memisahkan antar kelas, dapatkah salah satu dari grup tersebut dalam grafik dipisahkan hanya dengan menggunakan satu baris? Sepertinya tidak mungkin. Ini adalah tampilan sebagian besar data yang sebenarnya. Pemisahan yang paling dekat dengan kita adalah kombinasi dari skewness dan variance, atau entropy dan variance plot. Ini mungkin karena variance data yang memiliki bentuk distribusi yang mendekati normal.

Tetapi melihat semua grafik tersebut secara berurutan bisa sedikit sulit. Kami memiliki alternatif untuk melihat semua grafik distribusi dan pencar bersama-sama dengan menggunakan Seaborn's pairplot().

Kedua for loop sebelumnya yang telah kita lakukan dapat diganti hanya dengan baris ini:

sns.pairplot(bankdata, hue='class');

Melihat pairplot, tampaknya, sebenarnya, curtosis dan variance akan menjadi kombinasi fitur yang paling mudah, sehingga kelas yang berbeda dapat dipisahkan oleh garis, atau dapat dipisahkan secara linier.

Jika sebagian besar data jauh dari pemisahan linier, kita dapat mencoba memprosesnya terlebih dahulu, dengan mengurangi dimensinya, dan juga menormalkan nilainya untuk mencoba membuat distribusi mendekati normal.

Untuk kasus ini, mari gunakan data apa adanya, tanpa pemrosesan awal lebih lanjut, dan nanti, kita dapat mundur satu langkah, menambahkan pemrosesan awal data dan membandingkan hasilnya.

Menerapkan SVM dengan Scikit-Learn

Sebelum masuk lebih jauh ke dalam teori tentang bagaimana SVM bekerja, kita dapat membangun model dasar pertama kita dengan data, dan Scikit-Learn's Mendukung Pengklasifikasi Vektor or SVC kelas.

Model kami akan menerima koefisien wavelet dan mencoba mengklasifikasikannya berdasarkan kelas. Langkah pertama dalam proses ini adalah memisahkan koefisien atau fitur dari kelas atau target. Setelah langkah tersebut, langkah kedua selanjutnya adalah membagi data menjadi suatu himpunan yang akan digunakan untuk pembelajaran model atau set kereta api dan satu lagi yang akan digunakan untuk evaluasi model atau perangkat tes.

Membagi Data ke dalam Train/Test Sets

Pada sesi sebelumnya, kami memahami dan mengeksplorasi data. Sekarang, kita dapat membagi data kita dalam dua larik – satu untuk empat fitur, dan lainnya untuk fitur kelima, atau target. Karena kami ingin memprediksi kelas tergantung pada koefisien wavelet, kami y akan menjadi class kolom dan kami X akankah variance, skewness, curtosis, dan entropy kolom.

Untuk memisahkan target dan fitur, kami hanya dapat mengatributkan class kolom ke y, kemudian menjatuhkannya dari kerangka data untuk mengatribusikan kolom yang tersisa X dengan .drop() Metode:

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

Setelah data dibagi menjadi atribut dan label, selanjutnya kita dapat membaginya menjadi rangkaian pelatihan dan pengujian. Ini bisa dilakukan dengan tangan, tetapi model_selection perpustakaan Scikit-Learn berisi train_test_split() metode yang memungkinkan kita membagi data secara acak ke dalam rangkaian pelatihan dan pengujian.

Untuk menggunakannya, kita dapat mengimpor perpustakaan, memanggil train_test_split() metode, lewati X dan y data, dan tentukan a test_size untuk lulus sebagai argumen. Dalam hal ini, kami akan mendefinisikannya sebagai 0.20– ini berarti 20% data akan digunakan untuk pengujian, dan 80% lainnya untuk pelatihan.

Metode ini secara acak mengambil sampel sesuai dengan persentase yang telah kita tentukan, tetapi tetap menghormati pasangan Xy, jangan sampai pengambilan sampel tersebut benar-benar mencampuradukkan hubungan.

Karena proses pengambilan sampel pada dasarnya acak, kami akan selalu mendapatkan hasil yang berbeda saat menjalankan metode tersebut. Untuk mendapatkan hasil yang sama, atau hasil yang dapat direproduksi, kita dapat mendefinisikan konstanta yang disebut SEED dengan nilai 42.

Anda dapat menjalankan skrip berikut untuk melakukannya:

from sklearn.model_selection import train_test_split SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

Perhatikan bahwa train_test_split() metode sudah mengembalikan X_train, X_test, y_train, y_test mengatur dalam urutan ini. Kami dapat mencetak jumlah sampel yang dipisahkan untuk dilatih dan diuji dengan mendapatkan elemen (0) pertama dari shape properti mengembalikan tuple:

xtrain_samples = X_train.shape[0]
xtest_samples = X_test.shape[0] print(f'There are {xtrain_samples} samples for training and {xtest_samples} samples for testing.')

Hal ini menunjukkan bahwa terdapat 1097 sampel untuk pelatihan dan 275 untuk pengujian.

Melatih Model

Kami telah membagi data menjadi rangkaian pelatihan dan pengujian. Sekarang saatnya membuat dan melatih model SVM pada data latih. Untuk melakukan itu, kita dapat mengimpor Scikit-Learn's svm perpustakaan bersama dengan Mendukung Pengklasifikasi Vektor kelas, atau SVC kelas.

Setelah mengimpor kelas, kita dapat membuat turunannya – karena kita membuat model SVM sederhana, kita mencoba memisahkan data secara linier, sehingga kita dapat menggambar garis untuk membagi data kita – yang sama dengan menggunakan fungsi linear - dengan mendefinisikan kernel='linear' sebagai argumen untuk classifier:

from sklearn.svm import SVC
svc = SVC(kernel='linear')

Dengan cara ini, classifier akan mencoba menemukan fungsi linear yang memisahkan data kita. Setelah membuat model, mari kita latih, atau cocok itu, dengan data kereta, mempekerjakan fit() metode dan pemberian X_train fitur dan y_train target sebagai argumen.

Kita dapat mengeksekusi kode berikut untuk melatih model:

svc.fit(X_train, y_train)

Begitu saja, modelnya dilatih. Sejauh ini, kita telah memahami data, membaginya, membuat model SVM sederhana, dan memasang model tersebut ke data latih.

Langkah selanjutnya adalah memahami seberapa baik fit berhasil mendeskripsikan data kita. Dengan kata lain, untuk menjawab apakah SVM linier merupakan pilihan yang memadai.

Membuat Prediksi

Cara untuk menjawab jika model berhasil mendeskripsikan data adalah dengan menghitung dan melihat beberapa klasifikasi metrik.

Mengingat pembelajaran diawasi, kita dapat membuat prediksi dengan X_test dan bandingkan hasil prediksi tersebut – yang mungkin kita sebut y_pred - dengan yang sebenarnya y_test, atau kebenaran dasar.

Untuk memprediksi beberapa data, modelnya predict() metode dapat digunakan. Metode ini menerima fitur pengujian, X_test, sebagai argumen dan menampilkan prediksi, baik 0 atau 1, untuk masing-masing X_testbaris.

Setelah memprediksi X_test data, hasilnya disimpan dalam a y_pred variabel. Jadi masing-masing kelas diprediksi dengan model SVM linier sederhana sekarang di y_pred variabel.

Ini kode prediksinya:

y_pred = svc.predict(X_test)

Mengingat kami memiliki prediksi, sekarang kami dapat membandingkannya dengan hasil aktual.

Mengevaluasi Model

Ada beberapa cara untuk membandingkan prediksi dengan hasil aktual, dan mereka mengukur berbagai aspek klasifikasi. Beberapa metrik klasifikasi yang paling banyak digunakan adalah:

1. Matriks Kebingungan: ketika kita perlu mengetahui berapa banyak sampel yang kita dapatkan dengan benar atau salah setiap kelas. Nilai-nilai yang benar dan diprediksi dengan benar disebut positif sejati, yang diprediksi sebagai positif tetapi tidak positif disebut positif palsu. Nomenklatur yang sama dari negatif yang sebenarnya dan negatif palsu digunakan untuk nilai negatif;

2. Ketelitian: ketika tujuan kami adalah untuk memahami nilai prediksi yang benar apa yang dianggap benar oleh pengklasifikasi kami. Presisi akan membagi nilai positif sebenarnya dengan sampel yang diprediksi sebagai positif;

$$
presisi = frac{teks{positif benar}}{teks{positif benar} + teks{positif palsu}}
$$

3. Mengingat kembali: umumnya dihitung bersama dengan presisi untuk memahami berapa banyak positif sebenarnya yang diidentifikasi oleh pengklasifikasi kami. Penarikan kembali dihitung dengan membagi positif yang sebenarnya dengan apa pun yang seharusnya diprediksi sebagai positif.

$$
ingat = frac{teks{positif benar}}{teks{positif benar} + teks{negatif palsu}}
$$

4. Skor F1: apakah seimbang atau rata-rata harmonis presisi dan recall. Nilai terendah adalah 0 dan tertinggi adalah 1. Ketika f1-score sama dengan 1, itu berarti semua kelas diprediksi dengan benar – ini adalah skor yang sangat sulit diperoleh dengan data nyata (pengecualian hampir selalu ada).

$$
teks{f1-score} = 2* frac{text{precision} * teks{recall}}{text{precision} + teks{recall}}
$$

Kami telah mengenal matriks kebingungan, presisi, daya ingat, dan ukuran skor F1. Untuk menghitungnya, kita dapat mengimpor Scikit-Learn's metrics perpustakaan. Perpustakaan ini berisi classification_report dan confusion_matrix metode, metode laporan klasifikasi mengembalikan skor presisi, perolehan kembali, dan f1. Keduanya classification_report dan confusion_matrix dapat dengan mudah digunakan untuk mengetahui nilai untuk semua metrik penting tersebut.

Untuk menghitung metrik, kami mengimpor metode, memanggilnya, dan memberikan argumen klasifikasi yang diprediksi, y_test, dan label klasifikasi, atau y_true.

Untuk visualisasi matriks kebingungan yang lebih baik, kita dapat memplotnya di Seaborn's heatmap bersama dengan anotasi kuantitas, dan untuk laporan klasifikasi, yang terbaik adalah mencetak hasilnya, sehingga hasilnya diformat. Ini adalah kode berikut:

from sklearn.metrics import classification_report, confusion_matrix cm = confusion_matrix(y_test,y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Confusion matrix of linear SVM') print(classification_report(y_test,y_pred))

Ini menampilkan:

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

Dalam laporan klasifikasi, kita tahu ada presisi 0.99, recall 0.99 dan skor f1 0.99 untuk catatan palsu, atau kelas 0. Pengukuran tersebut diperoleh dengan menggunakan 148 sampel seperti yang ditunjukkan pada kolom pendukung. Sementara itu, untuk kelas 1 atau not real, hasilnya di bawah satu satuan, presisi 0.98, recall 0.98, dan skor f1 sama. Kali ini, 127 pengukuran citra digunakan untuk memperoleh hasil tersebut.

Jika kita melihat matriks kebingungan, kita juga dapat melihat bahwa dari 148 sampel kelas 0, 146 diklasifikasikan dengan benar, dan ada 2 positif palsu, sedangkan untuk 127 sampel kelas 1, ada 2 negatif palsu dan 125 positif benar.

Kita dapat membaca laporan klasifikasi dan matriks kebingungan, tetapi apa artinya?

Menafsirkan Hasil

Untuk mengetahui artinya, mari kita lihat semua metrik yang digabungkan.

Hampir semua sampel untuk kelas 1 diklasifikasikan dengan benar, ada 2 kesalahan model kami saat mengidentifikasi uang kertas yang sebenarnya. Ini sama dengan 0.98, atau 98%, ingat. Hal serupa dapat dikatakan tentang kelas 0, hanya 2 sampel yang salah diklasifikasikan, sedangkan 148 benar-benar negatif, dengan total presisi 99%.

Selain hasil tersebut, yang lainnya menandai 0.99, yang hampir 1, metrik yang sangat tinggi. Sering kali, ketika metrik setinggi itu terjadi dengan data kehidupan nyata, ini mungkin mengindikasikan model yang terlalu disesuaikan dengan data, atau berlebihan.

Saat ada overfit, model mungkin bekerja dengan baik saat memprediksi data yang sudah diketahui, namun kehilangan kemampuan untuk menggeneralisasi data baru, yang penting dalam skenario dunia nyata.

Tes cepat untuk mengetahui apakah terjadi overfit juga dengan data kereta. Jika model agak mengingat data kereta api, metriknya akan sangat mendekati 1 atau 100%. Ingatlah bahwa data latih lebih besar dari data uji – untuk alasan ini – cobalah untuk melihatnya secara proporsional, lebih banyak sampel, lebih banyak kemungkinan membuat kesalahan, kecuali ada beberapa overfit.

Untuk memprediksi dengan data latih, kita dapat mengulangi apa yang telah kita lakukan untuk data uji, tetapi sekarang dengan X_train:

y_pred_train = svc.predict(X_train) cm_train = confusion_matrix(y_train,y_pred_train)
sns.heatmap(cm_train, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with train data') print(classification_report(y_train,y_pred_train))

Output ini:

 precision recall f1-score support 0 0.99 0.99 0.99 614 1 0.98 0.99 0.99 483 accuracy 0.99 1097 macro avg 0.99 0.99 0.99 1097
weighted avg 0.99 0.99 0.99 1097

Sangat mudah untuk melihat tampaknya ada overfit, setelah metrik kereta mencapai 99% saat memiliki data 4 kali lebih banyak. Apa yang bisa dilakukan dalam skenario ini?

Untuk mengembalikan overfit, kita dapat menambahkan lebih banyak pengamatan kereta, gunakan metode pelatihan dengan bagian dataset yang berbeda, seperti validasi silang, dan juga mengubah parameter default yang sudah ada sebelum pelatihan, saat membuat model kita, atau hiperparameter. Sebagian besar waktu, Scikit-learn menetapkan beberapa parameter sebagai default, dan ini dapat terjadi secara diam-diam jika tidak ada banyak waktu untuk membaca dokumentasi.

Anda dapat memeriksa bagian kedua dari panduan ini (segera akan datang!) untuk melihat cara mengimplementasikan validasi silang dan melakukan penyetelan hyperparameter.

Kesimpulan

Pada artikel ini kita mempelajari SVM kernel linier sederhana. Kami mendapatkan intuisi di balik algoritme SVM, menggunakan kumpulan data nyata, menjelajahi data, dan melihat bagaimana data ini dapat digunakan bersama dengan SVM dengan mengimplementasikannya dengan pustaka Scikit-Learn Python.

Untuk terus berlatih, Anda dapat mencoba kumpulan data dunia nyata lainnya yang tersedia di tempat-tempat seperti Kaggle, UCI, Kumpulan data publik Big Query, universitas, dan situs web pemerintah.

Saya juga menyarankan agar Anda menjelajahi matematika sebenarnya di balik model SVM. Meskipun Anda belum tentu membutuhkannya untuk menggunakan algoritme SVM, masih sangat berguna untuk mengetahui apa yang sebenarnya terjadi di balik layar saat algoritme Anda menemukan batasan keputusan.

• 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-svm-and-kernel-svm-with-pythons-scikit-learn/