Metode Ensemble: Teknik Elegan untuk Menghasilkan Hasil Pembelajaran Mesin yang Lebih Baik

Metode ensemble adalah teknik yang membuat beberapa model dan kemudian menggabungkannya untuk menghasilkan hasil yang lebih baik. Metode ensemble biasanya menghasilkan solusi yang lebih akurat daripada model tunggal. Ini telah terjadi di sejumlah kompetisi pembelajaran mesin, di mana solusi pemenang menggunakan metode ensemble. Dalam Kompetisi Netflix yang populer, pemenangnya menggunakan metode ensemble untuk menerapkan algoritma penyaringan kolaboratif yang kuat. Contoh lainnya adalah KDD 2009 dimana pemenangnya juga menggunakan metode ensemble. Anda juga dapat menemukan pemenang yang menggunakan metode ini dalam kompetisi Kaggle, misalnya di sini adalah wawancara dengan pemenang kompetisi CrowdFlower.

Penting bagi kita untuk memahami beberapa istilah sebelum melanjutkan dengan artikel ini. Sepanjang artikel saya menggunakan istilah "model" untuk menggambarkan output dari algoritma yang dilatih dengan data. Model ini kemudian digunakan untuk membuat prediksi. Algoritme ini dapat berupa algoritme pembelajaran mesin apa pun seperti regresi logistik, pohon keputusan, dll. Model ini, bila digunakan sebagai input dari metode ensemble, disebut "model dasar".

Dalam posting blog ini saya akan membahas metode ensemble untuk klasifikasi dan menjelaskan beberapa metode ensemble yang dikenal luas: voting, susun, bagging dan boosting.

Metode Ensemble Berbasis Voting dan Rata-rata

Voting dan rata-rata adalah dua metode ensemble termudah. Keduanya mudah dipahami dan diterapkan. Voting digunakan untuk klasifikasi dan rata-rata digunakan untuk regresi.

Pada kedua metode, langkah pertama adalah membuat beberapa model klasifikasi/regresi menggunakan beberapa dataset pelatihan. Setiap model dasar dapat dibuat menggunakan pemisahan yang berbeda dari dataset pelatihan yang sama dan algoritma yang sama, atau menggunakan dataset yang sama dengan algoritma yang berbeda, atau metode lainnya. Pseudocode Python-esque berikut menunjukkan penggunaan dataset pelatihan yang sama dengan algoritma yang berbeda.

 train = load_csv("train.csv") target = train["target"] train = train.drop("target") test = load_csv("test.csv") algorithms = [logistic_regression, decision_tree_classification, ...] #for classification algorithms = [linear_regression, decision_tree_regressor, ...] #for regression predictions = matrix(row_length=len(target), column_length=len(algorithms)) for i,algorithm in enumerate(algorithms): predictions[,i] = algorithm.fit(train, target).predict(test)

Menurut pseudocode di atas, kami membuat prediksi untuk setiap model dan menyimpannya dalam matriks yang disebut prediksi di mana setiap kolom berisi prediksi dari satu model.

Suara terbanyak

Setiap model membuat prediksi (suara) untuk setiap contoh pengujian dan prediksi keluaran akhir adalah prediksi yang menerima lebih dari setengah suara. Jika tidak ada prediksi yang mendapatkan lebih dari setengah suara, kita dapat mengatakan bahwa metode ensemble tidak dapat membuat prediksi yang stabil untuk contoh ini. Meskipun ini adalah teknik yang banyak digunakan, Anda dapat mencoba prediksi yang paling banyak dipilih (bahkan jika itu kurang dari setengah suara) sebagai prediksi akhir. Dalam beberapa artikel, Anda mungkin melihat metode ini disebut "pemungutan suara pluralitas".

Pemungutan Suara Tertimbang

Tidak seperti pemungutan suara mayoritas, di mana setiap model memiliki hak yang sama, kita dapat meningkatkan pentingnya satu atau lebih model. Dalam pemungutan suara berbobot, Anda menghitung prediksi model yang lebih baik beberapa kali. Menemukan serangkaian bobot yang masuk akal terserah Anda.

Rata-rata Sederhana

Dalam metode rata-rata sederhana, untuk setiap contoh kumpulan data pengujian, prediksi rata-rata dihitung. Metode ini sering mengurangi overfit dan menciptakan model regresi yang lebih halus. Kode pseudocode berikut menunjukkan metode rata-rata sederhana ini:

 final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]) )

Rata-rata tertimbang

Rata-rata tertimbang adalah versi rata-rata sederhana yang sedikit dimodifikasi, di mana prediksi setiap model dikalikan dengan bobot dan kemudian rata-ratanya dihitung. Kode pseudocode berikut menunjukkan rata-rata tertimbang:

 weights = [..., ..., ...] #length is equal to len(algorithms) final_predictions = [] for row_number in len(predictions): final_predictions.append( mean(prediction[row_number, ]*weights) )

Susun Beberapa Model Pembelajaran Mesin

Penumpukan, juga dikenal sebagai generalisasi bertumpuk, adalah metode ensemble di mana model digabungkan menggunakan algoritme pembelajaran mesin lain. Ide dasarnya adalah untuk melatih algoritma pembelajaran mesin dengan dataset pelatihan dan kemudian menghasilkan dataset baru dengan model ini. Kemudian dataset baru ini digunakan sebagai input untuk algoritma pembelajaran mesin combiner.

Pseudocode dari prosedur penumpukan diringkas sebagai berikut:

 base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): stacking_train_dataset[,i] = base_algorithm.fit(train, target).predict(train) stacking_test_dataset[,i] = base_algorithm.predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

Seperti yang Anda lihat di pseudocode di atas, dataset pelatihan untuk algoritma combiner dihasilkan menggunakan output dari algoritma dasar. Dalam pseudocode, algoritma dasar dibangkitkan menggunakan dataset pelatihan dan kemudian dataset yang sama digunakan lagi untuk membuat prediksi. Namun seperti yang kita ketahui, di dunia nyata kita tidak menggunakan dataset pelatihan yang sama untuk prediksi, jadi untuk mengatasi masalah ini Anda mungkin melihat beberapa implementasi stacking dimana dataset pelatihan dipecah. Di bawah ini Anda dapat melihat pseudocode di mana dataset pelatihan dibagi sebelum melatih algoritma dasar:

 base_algorithms = [logistic_regression, decision_tree_classification, ...] #for classification stacking_train_dataset = matrix(row_length=len(target), column_length=len(algorithms)) stacking_test_dataset = matrix(row_length=len(test), column_length=len(algorithms)) for i,base_algorithm in enumerate(base_algorithms): for trainix, testix in split(train, k=10): #you may use sklearn.cross_validation.KFold of sklearn library stacking_train_dataset[testcv,i] = base_algorithm.fit(train[trainix], target[trainix]).predict(train[testix]) stacking_test_dataset[,i] = base_algorithm.fit(train).predict(test) final_predictions = combiner_algorithm.fit(stacking_train_dataset, target).predict(stacking_test_dataset)

Agregasi Bootstrap

Nama Bootstrap Aggregating, juga dikenal sebagai "Bagging", merangkum elemen kunci dari strategi ini. Dalam algoritma bagging, langkah pertama melibatkan pembuatan beberapa model. Model-model ini dibangkitkan menggunakan algoritma yang sama dengan sub-sampel acak dari dataset yang diambil dari dataset asli secara acak dengan metode bootstrap sampling. Dalam pengambilan sampel bootstrap, beberapa contoh asli muncul lebih dari satu kali dan beberapa contoh asli tidak ada dalam sampel. Jika Anda ingin membuat sub-set data dengan m elemen, Anda harus memilih elemen acak dari set data asli sebanyak m kali. Dan jika tujuannya adalah menghasilkan n kumpulan data, Anda mengikuti langkah ini sebanyak n kali.

Pada akhirnya, kami memiliki n set data di mana jumlah elemen di setiap set data adalah m. Pseudocode Python-esque berikut menunjukkan pengambilan sampel bootstrap:

 def bootstrap_sample(original_dataset, m): sub_dataset = [] for i in range(m): sub_dataset.append( random_one_element(original_dataset) ) return sub_dataset

Langkah kedua dalam bagging adalah menggabungkan model yang dihasilkan. Metode yang terkenal, seperti voting dan averaging, digunakan untuk tujuan ini.

Pseudocode keseluruhan terlihat seperti ini:

 def bagging(n, m, base_algorithm, train_dataset, target, test_dataset): predictions = matrix(row_length=len(target), column_length=n) for i in range(n): sub_dataset = bootstrap_sample(train_dataset, m) predictions[,i] = base_algorithm.fit(original_dataset, target).predict(test_dataset) final_predictions = voting(predictions) # for classification final_predictions = averaging(predictions) # for regression return final_predictions

Dalam bagging, setiap sub-sampel dapat dihasilkan secara independen satu sama lain. Jadi generasi dan pelatihan bisa dilakukan secara paralel.

Anda juga dapat menemukan penerapan strategi bagging di beberapa algoritme. Sebagai contoh, algoritma Random Forest menggunakan teknik bagging dengan beberapa perbedaan. Random Forest menggunakan pemilihan fitur acak, dan algoritma dasarnya adalah algoritma pohon keputusan.

Boosting: Mengubah Model Lemah menjadi Model Kuat

Istilah "meningkatkan" digunakan untuk menggambarkan keluarga algoritma yang mampu mengubah model lemah menjadi model yang kuat. Model lemah jika memiliki tingkat kesalahan yang besar, tetapi kinerjanya tidak acak (menghasilkan tingkat kesalahan 0,5 untuk klasifikasi biner). Boosting secara bertahap membangun ansambel dengan melatih setiap model dengan dataset yang sama tetapi bobot instance disesuaikan sesuai dengan kesalahan prediksi terakhir. Ide utamanya adalah memaksa model untuk fokus pada contoh yang sulit. Tidak seperti bagging, boosting adalah metode berurutan, sehingga Anda tidak dapat menggunakan operasi paralel di sini.

Prosedur umum algoritma boosting didefinisikan sebagai berikut:

 def adjust_dataset(_train, errors): #create a new dataset by using the hardest instances ix = get_highest_errors_index(train) return concat(_train[ix], random_select(train)) models = [] _train = random_select(train) for i in range(n): #n rounds model = base_algorithm.fit(_train) predictions = model.predict(_train) models.append(model) errors = calculate_error(predictions) _train = adjust_dataset(_train, errors) final_predictions = combine(models, test)

Fungsi adjust_dataset mengembalikan set data baru yang berisi instance tersulit, yang kemudian dapat digunakan untuk memaksa algoritme dasar untuk belajar.

Adaboost adalah algoritma yang dikenal luas yang merupakan metode boosting. Para pendiri Adaboost memenangkan Hadiah Godel untuk pekerjaan mereka. Umumnya, algoritma pohon keputusan lebih disukai sebagai algoritma dasar untuk Adaboost dan di perpustakaan sklearn algoritma dasar default untuk Adaboost adalah pohon keputusan (AdaBoostRegressor dan AdaBoostClassifier). Seperti yang telah kita bahas di paragraf sebelumnya, metode inkremental yang sama berlaku untuk Adaboost. Informasi yang dikumpulkan pada setiap langkah dari algoritma AdaBoost tentang 'kekerasan' dari setiap sampel pelatihan dimasukkan ke dalam model. Langkah 'menyesuaikan kumpulan data' berbeda dari langkah yang dijelaskan di atas dan langkah 'menggabungkan model' dihitung dengan menggunakan pemungutan suara berbobot.

Kesimpulan

Meskipun metode ansambel dapat membantu Anda memenangkan kompetisi pembelajaran mesin dengan merancang algoritme canggih dan menghasilkan hasil dengan akurasi tinggi, metode ini sering kali tidak disukai di industri di mana kemampuan interpretasi lebih penting. Meskipun demikian, efektivitas metode ini tidak dapat disangkal, dan manfaatnya dalam aplikasi yang tepat bisa sangat besar. Di bidang-bidang seperti perawatan kesehatan, bahkan peningkatan terkecil dalam akurasi algoritme pembelajaran mesin dapat menjadi sesuatu yang sangat berharga.