- pengantar
- Apa itu Model Ensemble dalam Pembelajaran Mesin?
- Metode Klasifikasi Ensemble yang Berbeda
- mengantongi
- meningkatkan
- Penumpukan
- Contoh
Implementasi
- Prapemrosesan Data
- Pembelajaran Mendalam Praktis untuk
Visi Komputer dengan Python
- Pendekatan Rata-rata Sederhana
- Contoh Klasifikasi VotingStacking
- Contoh Klasifikasi Bagging
- Meningkatkan Contoh Klasifikasi
- Menyimpulkan
pengantar
Model klasifikasi ensemble dapat menjadi alat pembelajaran mesin yang kuat yang mampu mencapai kinerja yang sangat baik dan menggeneralisasi dengan baik ke set data baru yang tidak terlihat.
Nilai dari pengklasifikasi ensemble adalah bahwa, dalam menggabungkan prediksi beberapa pengklasifikasi, ia dapat mengoreksi kesalahan yang dibuat oleh pengklasifikasi individu, yang mengarah ke akurasi yang lebih baik secara keseluruhan. Mari kita lihat berbagai metode klasifikasi ensemble dan lihat bagaimana pengklasifikasi ini dapat diterapkan di Scikit-Learn.
Apa itu Model Ensemble dalam Pembelajaran Mesin?
Kredit: Pixabay
Model ansambel adalah belajar ansambel metode yang menggabungkan algoritma yang berbeda bersama-sama. Dalam pengertian ini, ini adalah meta-algoritma daripada algoritma itu sendiri. Metode pembelajaran ensemble sangat berharga karena dapat meningkatkan kinerja model prediktif.
Metode pembelajaran ensemble bekerja dari gagasan bahwa mengikat prediksi beberapa pengklasifikasi bersama-sama akan menghasilkan kinerja yang lebih baik dengan meningkatkan akurasi prediksi atau mengurangi aspek seperti bias dan varians.
Secara umum, model ensemble jatuh ke dalam salah satu dari dua kategori: pendekatan sekuensial dan pendekatan paralel.
A ansambel berurutan model beroperasi dengan membuat pelajar/model dasar dihasilkan secara berurutan. Metode ensemble berurutan biasanya digunakan untuk mencoba dan meningkatkan kinerja secara keseluruhan, karena model ensemble dapat mengimbangi prediksi yang tidak akurat dengan memberi bobot kembali pada contoh yang sebelumnya salah diklasifikasikan. Contoh penting dari ini adalah AdaBoost.
A model paralel adalah, seperti yang mungkin bisa Anda tebak, metode yang mengandalkan penciptaan dan pelatihan pelajar dasar secara paralel. Metode paralel bertujuan untuk mengurangi tingkat kesalahan dengan melatih banyak model secara paralel dan merata-ratakan hasilnya bersama-sama. Contoh penting dari metode paralel adalah Random Forest Classifier.
Cara berpikir lain tentang ini adalah perbedaan antara homogen dan heterogen pelajar. Sementara sebagian besar metode pembelajaran ensemble menggunakan pembelajar berbasis homogen [banyak dari tipe pembelajar yang sama], beberapa metode ensemble menggunakan pembelajar heterogen [algoritma pembelajaran yang berbeda digabungkan bersama].
Untuk rekap:
- Model sekuensial mencoba meningkatkan kinerja dengan membobot ulang contoh, dan model dihasilkan secara berurutan.
- Model paralel bekerja dengan merata-ratakan hasil bersama-sama setelah melatih banyak model pada waktu yang sama.
Sekarang kita akan membahas berbagai metode dalam menggunakan model ini untuk memecahkan masalah klasifikasi pembelajaran mesin.
Metode Klasifikasi Ensemble yang Berbeda
mengantongi
Kredit: Wikimedia Commons
mengantongijuga dikenal sebagai agregasi bootstrap, adalah metode klasifikasi yang bertujuan untuk mengurangi varians estimasi dengan meratakan beberapa estimasi secara bersamaan. Bagging membuat subset dari dataset utama tempat peserta dilatih.
Agar prediksi dari pengklasifikasi yang berbeda digabungkan, baik rata-rata digunakan untuk regresi, atau pendekatan voting digunakan untuk klasifikasi [berdasarkan keputusan mayoritas].
Salah satu contoh metode klasifikasi bagging adalah Pengklasifikasi Hutan Acak. Dalam kasus pengklasifikasi hutan acak, semua pohon individu dilatih pada sampel dataset yang berbeda.
Pohon juga dilatih menggunakan pilihan fitur secara acak. Ketika hasilnya dirata-ratakan bersama-sama, varians keseluruhan menurun dan model berperforma lebih baik sebagai hasilnya.
meningkatkan
Meningkatkan algoritma mampu mengambil model yang lemah dan berkinerja buruk dan mengubahnya menjadi model yang kuat. Gagasan di balik algoritma boosting adalah bahwa Anda menetapkan banyak model pembelajaran yang lemah ke kumpulan data, dan kemudian bobot untuk contoh yang salah diklasifikasikan di-tweak selama putaran pembelajaran berikutnya.
Prediksi pengklasifikasi dikumpulkan dan kemudian prediksi akhir dibuat melalui jumlah tertimbang [dalam kasus regresi], atau suara mayoritas tertimbang [dalam kasus klasifikasi].
AdaBoost adalah salah satu contoh metode boosting classifier, seperti halnya Gradient Boosting, yang diturunkan dari algoritma tersebut di atas.
Jika Anda ingin membaca lebih lanjut tentang Gradient Boosting dan teori di baliknya, kami telah membahasnya di artikel sebelumnya.
Penumpukan
Kredit: Wikimedia Commons
Algoritma susun adalah metode pembelajaran ensemble yang menggabungkan keputusan regresi yang berbeda atau algoritma klasifikasi. Model komponen dilatih pada seluruh dataset pelatihan. Setelah model komponen ini dilatih, sebuah meta-model dirakit dari model yang berbeda dan kemudian dilatih pada output dari model komponen. Pendekatan ini biasanya menciptakan ansambel yang heterogen karena model komponen biasanya merupakan algoritma yang berbeda.
Contoh Implementasi
Sekarang kita telah menjelajahi berbagai metode yang dapat kita gunakan untuk membuat model ensemble, mari kita lihat bagaimana kita dapat mengimplementasikan classifier menggunakan metode yang berbeda.
Padahal, sebelum kita dapat melihat berbagai cara mengimplementasikan pengklasifikasi ensemble, kita perlu memilih kumpulan data untuk digunakan dan melakukan beberapa pemrosesan awal kumpulan data.
Kami akan menggunakan kumpulan data Titanic, yang dapat berupa download disini. Mari lakukan beberapa pra-pemrosesan data untuk menghilangkan nilai yang hilang dan menskalakan data ke rentang yang seragam. Kemudian kita bisa mengatur pengklasifikasi ensemble.
Prapemrosesan Data
Untuk memulainya, kita akan mulai dengan mengimpor semua fungsi yang kita butuhkan dari library masing-masing. Kami akan menggunakan panda dan numpy untuk memuat dan mengubah data, serta LabelEncoder dan StandardScalers.
Kami juga memerlukan metrik pembelajaran mesin dan train_test_split. Terakhir, kita membutuhkan pengklasifikasi yang ingin kita gunakan:
import pandas as pd import numpy as np import warnings from sklearn.preprocessing import LabelEncoder, StandardScaler from sklearn.metrics import accuracy_score, f1_score, log_loss from sklearn.model_selection import train_test_split, KFold, cross_val_score from sklearn.svm import SVC from sklearn.linear_model import LogisticRegression from sklearn.tree import DecisionTreeClassifier from sklearn.ensemble import VotingClassifier from sklearn.ensemble import BaggingClassifier from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier, ExtraTreesClassifier
Kami akan mulai dengan memuat data pelatihan dan pengujian, lalu membuat fungsi untuk memeriksa keberadaan nilai nol:
training_data = pd.read_csv["train.csv"]
testing_data = pd.read_csv["test.csv"]
def get_nulls[training, testing]:
print["Training Data:"]
print[pd.isnull[training].sum[]]
print["Testing Data:"]
print[pd.isnull[testing].sum[]]
get_nulls[training_data, testing_data]
Seperti yang terjadi, ada banyak nilai yang hilang di Age dan Cabin kategori.
Training Data: PassengerId 0 Survived 0 Pclass 0 Name 0 Sex 0 Age 177 SibSp 0 Parch 0 Ticket 0 Fare 0 Cabin 687 Embarked 2 dtype: int64 Testing Data: PassengerId 0 Pclass 0 Name 0 Sex 0 Age 86 SibSp 0 Parch 0 Ticket 0 Fare 1 Cabin 327 Embarked 0 dtype: int64
Kita akan mulai dengan menghapus beberapa kolom yang mungkin tidak berguna – the Cabin dan Ticket. Itu Cabin memiliki terlalu banyak nilai yang hilang dan Ticket hanya terdiri dari terlalu banyak kategori untuk menjadi berguna.
Pembelajaran Mendalam Praktis untuk Visi Komputer dengan Python
Saat Anda melihat cangkir kopi Anda, Anda sama sekali tidak terkejut dengan benda di depan Anda. Anda sudah bisa melakukan…
Cobalah
Setelah itu kita perlu memasukkan beberapa nilai yang hilang. Ketika kita melakukannya, kita harus memperhitungkan bagaimana dataset sedikit miring ke kanan [usia muda sedikit lebih menonjol daripada usia yang lebih tua]. Kami akan menggunakan nilai median saat kami menghubungkan data karena karena outlier besar mengambil nilai rata-rata akan memberi kami nilai yang diperhitungkan yang jauh dari pusat dataset:
# Drop the cabin column, as there are too many missing values # Drop the ticket numbers too, as there are too many categories # Drop names as they won't really help predict survivors training_data.drop[labels=['Cabin', 'Ticket', 'Name'], axis=1, inplace=True] testing_data.drop[labels=['Cabin', 'Ticket', 'Name'], axis=1, inplace=True] # Taking the mean/average value would be impacted by the skew # so we should use the median value to impute missing values training_data["Age"].fillna[training_data["Age"].median[], inplace=True] testing_data["Age"].fillna[testing_data["Age"].median[], inplace=True] training_data["Embarked"].fillna["S", inplace=True] testing_data["Fare"].fillna[testing_data["Fare"].median[], inplace=True] get_nulls[training_data, testing_data]
Sekarang kita dapat melihat tidak ada lagi nilai yang hilang:
Training Data: PassengerId 0 Survived 0 Pclass 0 Name 0 Sex 0 Age 0 SibSp 0 Parch 0 Fare 0 Embarked 0 dtype: int64 Testing Data: PassengerId 0 Pclass 0 Name 0 Sex 0 Age 0 SibSp 0 Parch 0 Fare 0 Embarked 0 dtype: int64
Kita sekarang perlu mengkodekan data non-numerik. Ayo siapkan LabelEncoder dan pas di Sex fitur dan kemudian mengubah data dengan encoder. Kami kemudian akan mengganti nilai di Sex fitur dengan yang telah dikodekan dan kemudian lakukan hal yang sama untuk Embarked fitur.
Terakhir, mari skalakan data menggunakan StandardScalerjadi tidak ada fluktuasi nilai yang besar.
encoder_1 = LabelEncoder[] # Fit the encoder on the data encoder_1.fit[training_data["Sex"]] # Transform and replace training data training_sex_encoded = encoder_1.transform[training_data["Sex"]] training_data["Sex"] = training_sex_encoded test_sex_encoded = encoder_1.transform[testing_data["Sex"]] testing_data["Sex"] = test_sex_encoded encoder_2 = LabelEncoder[] encoder_2.fit[training_data["Embarked"]] training_embarked_encoded = encoder_2.transform[training_data["Embarked"]] training_data["Embarked"] = training_embarked_encoded testing_embarked_encoded = encoder_2.transform[testing_data["Embarked"]] testing_data["Embarked"] = testing_embarked_encoded # Any value we want to reshape needs be turned into array first ages_train = np.array[training_data["Age"]].reshape[-1, 1] fares_train = np.array[training_data["Fare"]].reshape[-1, 1] ages_test = np.array[testing_data["Age"]].reshape[-1, 1] fares_test = np.array[testing_data["Fare"]].reshape[-1, 1] # Scaler takes arrays scaler = StandardScaler[] training_data["Age"] = scaler.fit_transform[ages_train] training_data["Fare"] = scaler.fit_transform[fares_train] testing_data["Age"] = scaler.fit_transform[ages_test] testing_data["Fare"] = scaler.fit_transform[fares_test]
Sekarang data kami telah diproses sebelumnya, kami dapat memilih fitur dan label kami dan kemudian menggunakan train_test_split untuk membagi seluruh data pelatihan kami menjadi set pelatihan dan pengujian:
# Now to select our training/testing data X_features = training_data.drop[labels=['PassengerId', 'Survived'], axis=1] y_labels = training_data['Survived'] print[X_features.head[5]] # Make the train/test data from validation X_train, X_val, y_train, y_val = train_test_split[X_features, y_labels, test_size=0.1, random_state=27]
Kami sekarang siap untuk mulai menerapkan metode klasifikasi ensemble.
Pendekatan Rata-rata Sederhana
Sebelum kita masuk ke tiga besar metode ensemble yang kita bahas sebelumnya, mari kita bahas metode yang sangat cepat dan mudah menggunakan pendekatan ensemble – prediksi rata-rata. Kami hanya menambahkan nilai prediksi yang berbeda dari pengklasifikasi yang kami pilih bersama-sama dan kemudian membagi dengan jumlah total pengklasifikasi, menggunakan pembagian lantai untuk mendapatkan nilai keseluruhan.
Dalam kasus uji ini kita akan menggunakan regresi logistik, Pengklasifikasi Pohon Keputusan, dan Pengklasifikasi Vektor Dukungan. Kami menyesuaikan pengklasifikasi pada data dan kemudian menyimpan prediksi sebagai variabel. Kemudian kita cukup menambahkan prediksi bersama dan membagi:
LogReg_clf = LogisticRegression[] DTree_clf = DecisionTreeClassifier[] SVC_clf = SVC[] LogReg_clf.fit[X_train, y_train] DTree_clf.fit[X_train, y_train] SVC_clf.fit[X_train, y_train] LogReg_pred = LogReg_clf.predict[X_val] DTree_pred = DTree_clf.predict[X_val] SVC_pred = SVC_clf.predict[X_val] averaged_preds = [LogReg_pred + DTree_pred + SVC_pred]//3 acc = accuracy_score[y_val, averaged_preds] print[acc]
Berikut akurasi yang kami dapatkan dari metode ini:
0.8444444444444444
Contoh Klasifikasi VotingStacking
Ketika datang untuk membuat pengklasifikasi susun/voting, Scikit-Learn memberi kita beberapa fungsi praktis yang dapat kita gunakan untuk mencapai ini.
Itu Pengklasifikasi Pemungutan Suara mengambil daftar estimator yang berbeda sebagai argumen dan metode pemungutan suara. Itu hard metode voting menggunakan label prediksi dan sistem aturan mayoritas, sedangkan soft metode voting memprediksi label berdasarkan argmax/nilai prediksi terbesar dari jumlah probabilitas yang diprediksi.
Setelah kami menyediakan pengklasifikasi yang diinginkan, kami perlu menyesuaikan objek pengklasifikasi ansambel yang dihasilkan. Kami kemudian bisa mendapatkan prediksi dan menggunakan metrik akurasi:
voting_clf = VotingClassifier[estimators=[['SVC', SVC_clf], ['DTree', DTree_clf], ['LogReg', LogReg_clf]], voting='hard'] voting_clf.fit[X_train, y_train] preds = voting_clf.predict[X_val] acc = accuracy_score[y_val, preds] l_loss = log_loss[y_val, preds] f1 = f1_score[y_val, preds] print["Accuracy is: " + str[acc]] print["Log Loss is: " + str[l_loss]] print["F1 Score is: " + str[f1]]
Inilah yang dikatakan metrik tentang VotingClassifierkinerja:
Accuracy is: 0.8888888888888888 Log Loss is: 3.8376684749044165 F1 Score is: 0.8484848484848486
Contoh Klasifikasi Bagging
Inilah cara kami menerapkan klasifikasi bagging dengan Scikit-Learn. Sklern’s BaggingClassifier mengambil model klasifikasi yang dipilih serta jumlah estimator yang ingin Anda gunakan – Anda dapat menggunakan model seperti Regresi Logistik atau Pohon Keputusan.
Sklearn juga menyediakan akses ke RandomForestClassifier dan ExtraTreesClassifier, yang merupakan modifikasi dari klasifikasi pohon keputusan. Pengklasifikasi ini juga dapat digunakan bersama dengan alat validasi silang K-folds.
Kami akan membandingkan beberapa pendekatan klasifikasi bagging yang berbeda di sini, mencetak hasil rata-rata dari skor validasi silang K-fold:
logreg_bagging_model = BaggingClassifier[base_estimator=LogReg_clf, n_estimators=50, random_state=12]
dtree_bagging_model = BaggingClassifier[base_estimator=DTree_clf, n_estimators=50, random_state=12]
random_forest = RandomForestClassifier[n_estimators=100, random_state=12]
extra_trees = ExtraTreesClassifier[n_estimators=100, random_state=12]
def bagging_ensemble[model]:
k_folds = KFold[n_splits=20, random_state=12]
results = cross_val_score[model, X_train, y_train, cv=k_folds]
print[results.mean[]]
bagging_ensemble[logreg_bagging_model]
bagging_ensemble[dtree_bagging_model]
bagging_ensemble[random_forest]
bagging_ensemble[extra_trees]
Inilah hasil yang kami dapatkan dari pengklasifikasi:
0.7865853658536585 0.8102439024390244 0.8002439024390245 0.7902439024390244
Meningkatkan Contoh Klasifikasi
Terakhir, kita akan melihat bagaimana menggunakan metode klasifikasi boosting. Seperti yang disebutkan, ada artikel terpisah tentang topik Peningkatan Gradien yang dapat Anda baca di sini.
Scikit-Learn memiliki built-in Pengklasifikasi AdaBoost, yang mengambil sejumlah estimator sebagai argumen pertama. Kita dapat mencoba menggunakan for loop untuk melihat bagaimana kinerja klasifikasi berubah pada nilai yang berbeda, dan kita juga dapat menggabungkannya dengan alat validasi silang K-Folds:
k_folds = KFold[n_splits=20, random_state=12]
num_estimators = [20, 40, 60, 80, 100]
for i in num_estimators:
ada_boost = AdaBoostClassifier[n_estimators=i, random_state=12]
results = cross_val_score[ada_boost, X_train, y_train, cv=k_folds]
print["Results for {} estimators:".format[i]]
print[results.mean[]]
Berikut hasil yang kami dapatkan:
Results for 20 estimators: 0.8015243902439024 Results for 40 estimators: 0.8052743902439025 Results for 60 estimators: 0.8053048780487805 Results for 80 estimators: 0.8040243902439024 Results for 100 estimators: 0.8027743902439024
Menyimpulkan
Kami telah membahas ide di balik tiga teknik klasifikasi ensemble yang berbeda: votingstacking, bagging, dan boosting.
Scikit-Learn memungkinkan Anda membuat instance dari pengklasifikasi ensemble yang berbeda dengan mudah. Objek ensemble ini dapat digabungkan dengan alat Scikit-Learn lainnya seperti validasi silang K-Folds.
Jika Anda ingin mempelajari lebih lanjut tentang penggunaan yang tepat untuk pengklasifikasi ansambel, dan teori di baliknya, saya sarankan untuk memeriksa tautan yang ditemukan di sini atau di sini.!