Keras: Evaluate the Skill of Deep Learning Model

Sumber: https://machinelearningmastery.com/evaluate-skill-deep-learning-models/

Sering terjadi kebingungan saat ingin mengevaluasi sebuah model deep learning, pertanyaan yang sering muncul seperti:

Random seed seperti apa yang perlu saya gunakan?
Mengapa kita memerlukan random seed?
Kenapa saya tidak memperoleh hasil yang sama di run selanjutnya?

Dalam tulisan ini, kita akan menemukan prosedur yang dapat kita gunakan untuk mengevaluasi model deep learning dan alasan untuk menggunakannya.

Kita juga akan menemukan statistik terkait yang berguna yang dapat kita hitung untuk menyajikan kemampuan model kita, seperti standar deviasi, kesalahan standar, dan interval keyakinan.

Kesalahan Pemula

Kita mem-fit model dengan data training dan mengevaluasinya pada dataset testing, kemudian melaporkan kemampuannya.

Mungkin saja kita menggunakan k-fold cross validation untuk mengevaluasi model, kemudian melaporkan kemampuan model.

Ini adalah kesalahan yang banyak dilakukan oleh pemula.

Sepertinya kita melakukan hal yang benar, tetapi ada masalah utama yang belum kita perhitungkan adalah:

Model Deep Learning bersifat stokastik.
Artificial neural networks menggunakan keacakan saat melakukan fit pada dataset, seperti awal weight acak dan pengacakan data setiap epoch training saat stochastic gradient descent.
Ini berarti bahwa setiap kali model yang sama di fit dengan data yang sama, akan memberikan prediksi yang berbeda yang pada akhirnya akan memberikan kemampuan model yang berbeda.

Mengestimasi Kemampuan Model

(Mengontrol Model Variance)

Kita tidak memiliki semua data yang mungkin; jika kita mempunyai hal tersebut, kita tidak perlu membuat prediksi.

Kita memiliki sampel data yang terbatas, dan dari situ kita perlu menemukan model terbaik yang kita bisa.

Menggunakan Train-Test Split

Kami melakukannya dengan membagi data menjadi dua bagian, fit model atau konfigurasi model tertentu pada bagian pertama data dan menggunakan model fit untuk membuat prediksi pada bagian lainnya, kemudian mengevaluasi kemampuan prediksi tersebut. Ini disebut train-test split dan kita menggunakan kemampuan sebagai perkiraan untuk seberapa baik kami berpikir model akan melakukan dalam praktiknya ketika membuat prediksi pada data baru.

Sebagai contoh, berikut adalah pseudocode untuk mengevaluasi sebuah model menggunakan train-test split:

train, test = split(data)
model = fit(train.X, train.y)
predictions = model.predict(test.X)
skill = compare(test.y, predictions)

Train-test split adalah pendekatan yang baik untuk digunakan jika kita memiliki banyak data atau model yang sangat lambat untuk di train, tetapi skor kemampuan yang dihasilkan untuk model tersebut akan noisy karena keacakan data (varians dari model) .

Ini berarti bahwa model yang sama di fit dengan data yang berbeda akan memberikan skor kemampuan model yang berbeda.

Penggunaan k-Fold Cross Validation

Kita sering dapat memperketat ini dan mendapatkan perkiraan kemampuan model yang lebih akurat menggunakan teknik seperti k-fold cross validation. Ini adalah teknik yang secara sistematis membagi data yang tersedia menjadi k-folds, cocok dengan model pada k-1 lipatan, mengevaluasinya pada lipatan yang tertahan, dan mengulangi proses ini untuk setiap lipatan.

Ini menghasilkan k model yang berbeda yang memiliki k set prediksi yang berbeda, dan pada gilirannya, k skor kemampuan yang berbeda.

Misalnya, berikut adalah pseudocode untuk mengevaluasi suatu model menggunakan k-fold cross validation:

scores = list()
for i in k:
	train, test = split_old(data, i)
	model = fit(train.X, train.y)
	predictions = model.predict(test.X)
	skill = compare(test.y, predictions)
 	scores.append(skill)

Sebuah populasi skor keterampilan lebih berguna karena kita dapat mengambil rata-rata dan melaporkan rata-rata kemampuan yang diharapkan dari model, yang kemungkinan akan lebih dekat dengan kemampuan sebenarnya dari model dalam praktik. Sebagai contoh:

mean_skill = sum(scores) / count(scores)

Kami juga dapat menghitung deviasi standar menggunakan mean_skill untuk mendapatkan gambaran tentang penyebaran skor rata-rata di sekitar mean_skill:

standard_deviation = sqrt(1/count(scores) * sum( (score - mean_skill)^2 ))

Mengestimasi Kemampuan Sebuah Stochastic Model

(Mengontrol Model Stability)

Model stokastik, seperti deep neural network, menambahkan sumber keacakan.

Keacakan tambahan ini memberi model lebih banyak fleksibilitas saat belajar, tetapi dapat membuat model menjadi kurang stabil (mis. hasil yang berbeda ketika model yang sama dilatih pada data yang sama). This is different from model variance that gives different results when the same model is trained on different data.

Untuk mendapatkan perkiraan yang lebih baik dari kemampuan model stokastik, kita harus memperhitungkan sumber varians tambahan ini; kita harus bisa mengendalikannya.

Fix Random Seed

Salah satu caranya adalah dengan menggunakan keacakan yang sama setiap kali model di fit. Kita dapat melakukannya dengan menetapkan seed random yang digunakan oleh sistem dan kemudian mengevaluasi atau menyesuaikan model. Sebagai contoh:

seed(1)
scores = list()
for i in k:
	train, test = split_old(data, i)
	model = fit(train.X, train.y)
	predictions = model.predict(test.X)
	skill = compare(test.y, predictions)
	scores.append(skill)

Ini bagus untuk tutorial dan demonstrasi ketika hasil yang sama diperlukan setiap kali program kita dijalankan.

Ini fragile dan tidak direkomendasikan untuk mengevaluasi model.

See the post:

Embrace Randomness in Machine Learning
How to Get Reproducible Results with Keras

Pengulangan Experimen Evaluasi

Pendekatan yang lebih baik adalah mengulang percobaan mengevaluasi model non-stokastik beberapa kali. Contoh:

scores = list()
for i in repeats:
	run_scores = list()
	for j in k:
		train, test = split_old(data, j)
		model = fit(train.X, train.y)
		predictions = model.predict(test.X)
		skill = compare(test.y, predictions)
		run_scores.append(skill)
	scores.append(mean(run_scores))

Catatan, kita menghitung rata-rata perkiraan kemampuan rate-rata model, yang disebut grand mean.

Berikut adalah saran cara memperkirakan kemampuan model deep learning.

Karena pengulangan sering> = 30, kita dapat dengan mudah menghitung kesalahan standar dari kemampuan rata-rata model, yaitu seberapa banyak rata-rata perkiraan skor keterampilan model berbeda dari keterampilan model rata-rata aktual yang tidak diketahui (mis. seberapa salah mean_skill)

standard_error = standard_deviation / sqrt(count(scores))

Selanjutnya, kita bisa menggunakan standard_error untuk menghitung interval kepercayaan untuk mean_skill. Ini mengasumsikan bahwa distribusi hasilnya adalah Gaussian, yang dapat kita periksa dengan melihat pada Histogram, plot Q-Q, atau menggunakan test statistik pada skor yang dikumpulkan.

Misalnya, interval 95% adalah (1,96 * standard_error) di sekitar kemampuan rata-rata.

interval = standard_error * 1.96
lower_interval = mean_skill - interval
upper_interval = mean_skill + interval

Metoda lain yang mungkin lebih baik secara statistik untuk menghitung interval kepercayaan daripada menggunakan standard error of grand mean, seperti:

Calculating the Binomial proportion confidence interval.
Using the bootstrap to estimate an empirical confidence interval.

Seberapa Tidak Stabilkah Neural Network?

Itu tergantung pada masalah anda, pada jaringan, dan pada konfigurasinya.

Sangat di sarankan untuk melakukan sensitivity analysis untuk mencari tahu.

Mengevaluasi model yang sama pada data yang sama berkali-kali (30, 100, atau ribuan) dan hanya memvariasikan seed untuk generator angka random.

Kemudian review rata-rata dan standar deviasi skor keterampilan yang dihasilkan. Deviasi standar (jarak rata-rata skor dari skor rata-rata) akan memberi anda gambaran betapa tidak stabilnya model anda.

Berapa Kali Repeat / Pengulangan?

Rekomendasinya setidaknya 30, mungkin 100, bahkan ribuan, hanya dibatasi oleh waktu dan sumber daya komputer Anda, dan jika semakin tidak menguntungkan (mis. standard error pada mean_skill yang semakin tinggi).

Lebih tepatnya, saya akan merekomendasikan percobaan yang melihat dampak pada estimasi kemampuan model versus jumlah pengulangan dan perhitungan standard error (berapa banyak rata-rata kinerja yang diperkirakan berbeda dari rata-rata populasi sebenarnya).

Summary

Dalam tulisan ini, kita menemukan cara mengevaluasi kemampuan deep learning model.

Terutama, kita belajar:

Kesalahan umum yang dilakukan oleh pemula ketika mengevaluasi deep learning model.
Alasan untuk menggunakan repeated k-fold cross validation untuk mengevaluasi deep learning model.
Cara menghitung statistik kemampuan model terkait, seperti standar deviasi, standard error, dan interval kepercayaan.

Referensi

https://machinelearningmastery.com/evaluate-skill-deep-learning-models/

Pranala Menarik

Keras
Python