Memahami SVM Hyperparameter

Pengantar

Panduan ini adalah bagian kedua dari tiga panduan tentang Support Vector Machines (SVM). Dalam panduan ini, kami akan terus mengerjakan kasus penggunaan uang kertas palsu, memahami parameter SVM apa yang telah ditetapkan oleh Scikit-learn, apa itu hyperparameter C dan Gamma, dan cara menyetelnya menggunakan validasi silang dan pencarian kisi.

Dalam panduan SVM seri lengkap, selain hyperparameter SVM, Anda juga akan belajar tentang SVM sederhana, sebuah konsep yang disebut trik kernel, dan jelajahi jenis SVM lainnya.

Jika Anda ingin membaca semua panduan, lihat panduan pertama, atau lihat mana yang paling menarik bagi Anda, di bawah ini adalah tabel topik yang tercakup 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 Hyperparameter SVM

• 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

Mari pelajari cara mengimplementasikan validasi silang dan melakukan penyetelan hyperparameter.

Hyperparameter SVM

Untuk melihat semua parameter model yang sudah diatur oleh Scikit-learn dan nilai defaultnya, kita bisa menggunakan get_params() Metode:

svc.get_params()

Metode ini menampilkan:

{'C': 1.0, 'break_ties': False, 'cache_size': 200, 'class_weight': None, 'coef0': 0.0, 'decision_function_shape': 'ovr', 'degree': 3, 'gamma': 'scale', 'kernel': 'linear', 'max_iter': -1, 'probability': False, 'random_state': None, 'shrinking': True, 'tol': 0.001, 'verbose': False}

Perhatikan bahwa ada total 15 hyperparameter yang telah ditetapkan, hal ini terjadi karena algoritma SVM memiliki banyak variasi. Kami telah menggunakan kernel linier untuk mendapatkan fungsi linier, tetapi ada juga kernel yang menjelaskan jenis fungsi lain dan kernel tersebut diparametrikan dengan cara yang berbeda.

Variasi ini terjadi untuk membuat model lebih fleksibel dan cocok untuk menemukan pemisahan antara berbagai bentuk data. Jika kita dapat menarik garis untuk memisahkan kelas kita, maka a kernel linier akan menjadi pilihan yang baik, jika kita membutuhkan kurva, maka a polinomial kernel mungkin menjadi pilihan terbaik, jika data kita berbentuk lingkaran, maka a Fungsi Basis Radial or RBF kernel akan menyesuaikan data dengan lebih baik, jika ada nilai di atas dan di bawah ambang batas, a sigmoid.dll kernel mungkin memisahkan kelas dengan lebih baik. Dari apa yang telah kami jelajahi dalam data kami, tampaknya RBF atau kernel polinomial akan lebih cocok daripada kernel linier.

Sekarang kita memiliki gagasan bahwa ada 4 jenis fungsi kernel yang berbeda, kita dapat kembali ke parameternya. Ketika algoritme SVM mencoba menemukan pemisahan antar kelas, kami telah memahami bahwa ia menggambar klasifikasi batas antara vektor pendukung dan garis pemisah (atau kurva).

Margin ini, dalam arti tertentu, seperti penyangga antara garis pemisah dan titik-titik. Ukuran margin dapat bervariasi, ketika margin lebih kecil, ada lebih sedikit ruang untuk titik yang berada di luar margin, membuat pemisahan antar kelas menjadi lebih jelas, sehingga lebih banyak sampel yang diambil diklasifikasikan dengan benar, sebaliknya, ketika marginnya adalah lebih besar, pemisahan antar kelas kurang jelas, dan sampel bisa lebih banyak salah klasifikasi. Dengan kata lain, margin yang lebih kecil berarti sampel yang diklasifikasikan lebih tepat, dan juga lebih banyak kaku classifier, sementara margin yang lebih besar, menunjukkan lebih banyak sampel yang salah klasifikasi, tetapi lebih banyak fleksibel penggolong.

Saat margin tersebut dipilih, parameter yang menentukannya adalah C parameter.

Hiperparameter C

Grafik C parameter berbanding terbalik dengan ukuran margin, ini berarti bahwa lebih besar nilai C, yang lebih kecil margin, dan, sebaliknya, lebih kecil nilai C, yang lebih besar margin. Itu C parameter dapat digunakan bersama dengan kernel apa pun, ini memberi tahu algoritme berapa banyak yang harus dihindari kesalahan klasifikasi setiap sampel pelatihan, oleh karena itu, ini juga dikenal sebagai regularisasi. SVM kernel linier kami telah menggunakan a C sebesar 1.0, yaitu a besar nilai dan memberikan a margin yang lebih kecil.

Kita dapat melakukan percobaan dengan a lebih kecil nilai 'C' dan memahami dalam praktek apa yang terjadi dengan a margin yang lebih besar. Untuk melakukan itu, kita akan membuat classifier baru, svc_c, dan hanya mengubah nilai dari C untuk 0.0001. Mari kita ulangi juga fit dan predict Langkah:

svc_c = SVC(kernel='linear', C=0.0001)
svc_c.fit(X_train, y_train)
y_pred_c = svc_c.predict(X_test)

Sekarang kita dapat melihat hasil untuk data uji:

print(classification_report(y_test, y_pred_c)) cm_c = confusion_matrix(y_test, y_pred_c)
sns.heatmap(cm_c, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with C=0.0001')

Output ini:

 precision recall f1-score support 0 0.82 0.96 0.88 148 1 0.94 0.76 0.84 127 accuracy 0.87 275 macro avg 0.88 0.86 0.86 275
weighted avg 0.88 0.87 0.86 275

Dengan menggunakan yang lebih kecil C dan memperoleh margin yang lebih besar, pengklasifikasi menjadi lebih fleksibel dan dengan lebih banyak kesalahan klasifikasi. Dalam laporan klasifikasi, kita dapat melihat bahwa f1-score, sebelumnya 0.99 untuk kedua kelas, telah turun menjadi 0.88 untuk kelas 0, dan menjadi 0.84 untuk kelas 1. Dalam matriks konfusi, model berubah dari 2 menjadi 6 positif palsu, dan dari 2 menjadi 31 negatif palsu.

Kita juga bisa mengulang predict langkah dan lihat hasilnya untuk memeriksa apakah masih ada overfit saat menggunakan data kereta:

y_pred_ct = svc_c.predict(X_train) cm_ct = confusion_matrix(y_train, y_pred_ct)
sns.heatmap(cm_ct, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with C=0.0001 and train data') print(classification_report(y_train, y_pred_ct))

Ini menghasilkan:

 precision recall f1-score support 0 0.88 0.96 0.92 614 1 0.94 0.84 0.88 483 accuracy 0.90 1097 macro avg 0.91 0.90 0.90 1097
weighted avg 0.91 0.90 0.90 1097

Dengan melihat hasil dengan lebih kecil C dan data latih, kita dapat melihat ada peningkatan pada overfit, tetapi setelah sebagian besar metrik masih lebih tinggi untuk data latih, tampaknya overfit belum terpecahkan. Jadi, hanya mengubah C parameter tidak cukup untuk membuat model lebih fleksibel dan meningkatkan generalisasinya.

Sampai saat ini, kita telah memahami tentang margin dalam SVM dan bagaimana pengaruhnya terhadap keseluruhan hasil algoritme, tetapi bagaimana dengan garis (atau kurva) yang memisahkan kelas? Baris ini adalah batas keputusan. Jadi, kita sudah tahu bahwa margin berdampak pada fleksibilitas batas keputusan terhadap kesalahan, sekarang kita bisa melihat parameter lain yang juga mempengaruhi batas keputusan.

Hiperparameter Gamma

Batas keputusan tak terbatas dapat dipilih, beberapa dari batas tersebut akan memisahkan kelas dan yang lainnya tidak. Saat memilih batas keputusan yang efektif haruskah 10 titik terdekat pertama dari setiap kelas dipertimbangkan? Atau harus lebih banyak poin yang dipertimbangkan, termasuk poin yang jaraknya jauh? Di SVM, pilihan rentang tersebut ditentukan oleh hyperparameter lain, gamma.

Seperti C, gamma agak berbanding terbalik dengan jaraknya. Itu lebih tinggi nilainya, the paling dekat adalah titik-titik yang dipertimbangkan untuk batas keputusan, dan terendah itu gamma, yang lebih jauh poin juga dipertimbangkan untuk memilih batas keputusan.

Dampak lain dari gamma, adalah bahwa semakin tinggi nilainya, semakin banyak ruang lingkup batas keputusan semakin dekat dengan titik-titik di sekitarnya, membuatnya lebih bergerigi dan cenderung overfit – dan semakin rendah nilainya, semakin halus dan teratur batas keputusan permukaan menjadi, juga, kurang rentan terhadap overfit. Ini berlaku untuk hyperplane apa pun, tetapi dapat lebih mudah diamati saat memisahkan data dalam dimensi yang lebih tinggi. Dalam beberapa dokumentasi, gamma bisa juga disebut sebagai sigma.

Dalam kasus model kami, nilai default dari gamma adalah scale. Seperti yang dapat dilihat di Dokumentasi SVC belajar Scikit, artinya nilainya adalah:

$$
gamma = (1/ teks{n_features} * X.var())
$$

or

$$
gamma = (1/ teks{jumlah_fitur} * teks{variasi_fitur})
$$

Dalam kasus kita, kita perlu menghitung varian dari X_train, kalikan dengan 4 dan bagi hasilnya dengan 1. Kita dapat melakukannya dengan kode berikut:

number_of_features = X_train.shape[1] features_variance = X_train.values.var()
gamma = 1/(number_of_features * features_variance)
print('gamma:', gamma)

Output ini:

gamma: 0.013924748072859962

Ada juga cara lain untuk melihat nilai dari gamma, dengan mengakses objek classifier gamma parameter dengan ._gamma:

svc._gamma 

Kita dapat melihat bahwa gamma digunakan dalam pengklasifikasi kami rendah, sehingga juga mempertimbangkan poin yang lebih jauh.

Tidak ada aturan tentang bagaimana memilih nilai untuk hyperparameter, seperti C dan gamma – itu akan tergantung pada berapa lama dan sumber daya apa yang tersedia untuk bereksperimen dengan nilai hyperparameter yang berbeda, transformasi apa yang dapat dilakukan pada data, dan hasil apa yang diharapkan . Cara biasa untuk mencari nilai hyperparameter adalah dengan menggabungkan setiap nilai yang diusulkan melalui a pencarian grid bersama dengan prosedur yang menerapkan nilai hyperparameter tersebut dan mendapatkan metrik untuk berbagai bagian data yang disebut validasi silang. Di Scikit-learn, ini sudah diimplementasikan sebagai GridSearchCV (CV dari validasi silang) metode.

Untuk menjalankan pencarian grid dengan validasi silang, kita perlu mengimpor file GridSearchCV, tentukan kamus dengan nilai hyperparameter yang akan diuji coba, seperti tipe dari kernel, kisaran untuk C, Dan untuk gamma, buat instance dari SVC, tentukan score atau metrik akan digunakan untuk mengevaluasi (di sini kami akan memilih untuk mengoptimalkan presisi dan daya ingat, jadi kami akan menggunakan f1-score), jumlah pembagian yang akan dibuat dalam data untuk menjalankan pencarian cv – standarnya adalah 5, tetapi sebaiknya gunakan setidaknya 10 – di sini, kami akan menggunakan 5 lipatan data agar lebih jelas saat membandingkan hasil.

Grafik GridSearchCV memiliki fit metode yang menerima data pelatihan kami dan selanjutnya membaginya menjadi set pelatihan dan pengujian untuk validasi silang. Kita bisa mengatur return_train_score ke true untuk membandingkan hasil dan menjamin tidak ada overfit.

Ini adalah kode untuk pencarian grid dengan validasi silang:

from sklearn.model_selection import GridSearchCV parameters_dictionary = {'kernel':['linear', 'rbf'], 'C':[0.0001, 1, 10], 'gamma':[1, 10, 100]}
svc = SVC() grid_search = GridSearchCV(svc, parameters_dictionary, scoring = 'f1', return_train_score=True, cv = 5, verbose = 1) grid_search.fit(X_train, y_train)

Kode ini menghasilkan:

Fitting 5 folds for each of 18 candidates, totalling 90 fits
# and a clickable GridSeachCV object schema

Setelah melakukan pencarian hyperparameter, kita dapat menggunakan best_estimator_, best_params_ dan best_score_ properti untuk mendapatkan model terbaik, nilai parameter, dan skor f1 tertinggi:

best_model = grid_search.best_estimator_
best_parameters = grid_search.best_params_
best_f1 = grid_search.best_score_ print('The best model was:', best_model)
print('The best parameter values were:', best_parameters)
print('The best f1-score was:', best_f1)

Ini menghasilkan:

The best model was: SVC(C=1, gamma=1)
The best parameter values were: {'C': 1, 'gamma': 1, 'kernel': 'rbf'}
The best f1-score was: 0.9979166666666666

Mengonfirmasi tebakan awal kami dari melihat data, model terbaik tidak memiliki kernel linier, tetapi nonlinier, RBF.

Kedua C dan gamma memiliki nilai 1, dan f1-score sangat tinggi, 0.99. Karena nilainya tinggi, mari kita lihat apakah ada overfit dengan melihat nilai rata-rata tes dan latihan yang telah kita kembalikan, di dalam cv_results_ obyek:

gs_mean_test_scores = grid_search.cv_results_['mean_test_score']
gs_mean_train_scores = grid_search.cv_results_['mean_train_score'] print("The mean test f1-scores were:", gs_mean_test_scores)
print("The mean train f1-scores were:", gs_mean_train_scores)

Skor rata-rata adalah:

The mean test f1-scores were: [0.78017291 0. 0.78017291 0. 0.78017291 0. 0.98865407 0.99791667 0.98865407 0.76553515 0.98865407 0.040291 0.98656 0.99791667 0.98656 0.79182565 0.98656 0.09443985] The mean train f1-scores were: [0.78443424 0. 0.78443424 0. 0.78443424 0. 0.98762683 1. 0.98762683 1. 0.98762683 1. 0.98942923 1. 0.98942923 1. 0.98942923 1. ]

Dengan melihat skor rata-rata, kita dapat melihat bahwa yang tertinggi, 0.99791667 muncul dua kali, dan dalam kedua kasus, skor dalam data kereta adalah 1. Hal ini mengindikasikan bahwa overfit tetap ada. Dari sini, akan menarik untuk kembali ke persiapan data dan memahami apakah masuk akal untuk menormalkan data, membuat beberapa jenis transformasi data lainnya, dan juga membuat fitur baru dengan rekayasa fitur.

Kami baru saja melihat teknik untuk menemukan hyperparameter model, dan kami telah menyebutkan sesuatu tentang keterpisahan linier, vektor dukungan, batas keputusan, maksimalisasi margin, dan trik kernel. SVM adalah algoritme yang kompleks, biasanya dengan banyak konsep matematika yang terlibat dan bagian-bagian kecil yang dapat diubah yang perlu disesuaikan untuk digabungkan secara keseluruhan.

Mari gabungkan apa yang telah kita lihat sejauh ini, buat rekap tentang cara kerja semua bagian SVM, lalu lihat beberapa implementasi kernel lainnya beserta hasilnya.

Kesimpulan

Pada artikel ini kami memahami tentang parameter default di balik implementasi SVM Scikit-Learn. Kami memahami apa itu parameter C dan Gamma, dan bagaimana mengubah masing-masing parameter tersebut dapat memengaruhi model SVM.

Kita juga belajar tentang pencarian grid untuk mencari nilai C dan Gamma terbaik, dan menggunakan validasi silang untuk menggeneralisasikan hasil kita dengan lebih baik dan menjamin bahwa tidak ada bentuk kebocoran data.

Melakukan penyetelan hyperparameter dengan pencarian grid dan validasi silang adalah praktik umum dalam ilmu data, jadi saya sangat menyarankan Anda menerapkan tekniknya, menjalankan kode, dan melihat tautan antara nilai hyperparameter dan perubahan dalam prediksi SVM.

• 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/understanding-svm-hyperparameters/