Difference between revisions of "Keras: Evaluate the Skill of Deep Learning Model"

From OnnoWiki
Jump to navigation Jump to search
 
(15 intermediate revisions by the same user not shown)
Line 13: Line 13:
  
  
−
==The Beginner’s Mistake==
+
==Kesalahan Pemula==
  
−
You fit the model to your training data and evaluate it on the test dataset, then report the skill.
+
Kita mem-fit model dengan data training dan mengevaluasinya pada dataset testing, kemudian melaporkan kemampuannya.
  
−
Perhaps you use k-fold cross validation to evaluate the model, then report the skill of the model.
+
Mungkin saja kita menggunakan k-fold cross validation untuk mengevaluasi model, kemudian melaporkan kemampuan model.
  
−
This is a mistake made by beginners.
+
Ini adalah kesalahan yang banyak dilakukan oleh pemula.
  
−
It looks like you’re doing the right thing, but there is a key issue you have not accounted for:
+
Sepertinya kita melakukan hal yang benar, tetapi ada masalah utama yang belum kita perhitungkan adalah:
  
−
Deep learning models are stochastic.
+
* 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.
  
−
Artificial neural networks use randomness while being fit on a dataset, such as random initial weights and random shuffling of data during each training epoch during stochastic gradient descent.
+
==Mengestimasi Kemampuan Model==
 +
(Mengontrol Model Variance)
  
−
This means that each time the same model is fit on the same data, it may give different predictions and in turn have different overall skill.
+
Kita tidak memiliki semua data yang mungkin; jika kita mempunyai hal tersebut, kita tidak perlu membuat prediksi.
  
−
==Estimating Model Skill==
+
Kita memiliki sampel data yang terbatas, dan dari situ kita perlu menemukan model terbaik yang kita bisa.
−
(Controlling for Model Variance)
 
  
−
We don’t have all possible data; if we did, we would not need to make predictions.
+
==Menggunakan Train-Test Split==
  
−
We have a limited sample of data, and from it we need to discover the best model we can.
+
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.
  
−
==Use a Train-Test Split==
+
Sebagai contoh, berikut adalah pseudocode untuk mengevaluasi sebuah model menggunakan train-test split:
−
 
 
−
We do that by splitting the data into two parts, fitting a model or specific model configuration on the first part of the data and using the fit model to make predictions on the rest, then evaluating the skill of those predictions. This is called a train-test split and we use the skill as an estimate for how well we think the model will perform in practice when it makes predictions on new data.
 
−
 
 
−
For example, here’s some pseudocode for evaluating a model using a train-test split:
 
  
 
  train, test = split(data)
 
  train, test = split(data)
Line 47: Line 45:
 
  skill = compare(test.y, predictions)
 
  skill = compare(test.y, predictions)
  
−
A train-test split is a good approach to use if you have a lot of data or a very slow model to train, but the resulting skill score for the model will be noisy because of the randomness in the data (variance of the model).
+
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) .
  
−
This means that the same model fit on different data will give different model skill scores.
+
Ini berarti bahwa model yang sama di fit dengan data yang berbeda akan memberikan skor kemampuan model yang berbeda.
  
−
==Use k-Fold Cross Validation==
+
==Penggunaan k-Fold Cross Validation==
  
−
We can often tighten this up and get more accurate estimates of model skill using techniques like k-fold cross validation. This is a technique that systematically splits up the available data into k-folds, fits the model on k-1 folds, evaluates it on the held out fold, and repeats this process for each fold.
+
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.
  
−
This results in k different models that have k different sets of predictions, and in turn, k different skill scores.
+
Ini menghasilkan k model yang berbeda yang memiliki k set prediksi yang berbeda, dan pada gilirannya, k skor kemampuan yang berbeda.
  
−
For example, here’s some pseudocode for evaluating a model using a k-fold cross validation:
+
Misalnya, berikut adalah pseudocode untuk mengevaluasi suatu model menggunakan  k-fold cross validation:
  
 
  scores = list()
 
  scores = list()
Line 67: Line 65:
 
   scores.append(skill)
 
   scores.append(skill)
  
−
A population of skill scores is more useful as we can take the mean and report the average expected performance of the model, which is likely to be closer to the actual performance of the model in practice. For example:
+
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)
 
  mean_skill = sum(scores) / count(scores)
  
−
We can also calculate a standard deviation using the mean_skill to get an idea of the average spread of scores around the mean_skill:
+
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 ))
 
  standard_deviation = sqrt(1/count(scores) * sum( (score - mean_skill)^2 ))
  
−
==Estimating a Stochastic Model’s Skill==
+
==Mengestimasi Kemampuan Sebuah Stochastic Model==
−
(Controlling for Model Stability)
+
(Mengontrol Model Stability)
  
−
Stochastic models, like deep neural networks, add an additional source of randomness.
+
Model stokastik, seperti deep neural network, menambahkan sumber keacakan.
−
 
 
−
This additional randomness gives the model more flexibility when learning, but can make the model less stable (e.g. different results when the same model is trained on the same data).
 
  
 +
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.
 
This is different from model variance that gives different results when the same model is trained on different data.
  
−
To get a robust estimate of the skill of a stochastic model, we must take this additional source of variance into account; we must control for it.
+
Untuk mendapatkan perkiraan yang lebih baik dari kemampuan model stokastik, kita harus memperhitungkan sumber varians tambahan ini; kita harus bisa mengendalikannya.
  
−
==Fix the Random Seed==
+
==Fix Random Seed==
  
−
One way is to use the same randomness every time the model is fit. We can do that by fixing the random number seed used by the system and then evaluating or fitting the model. For example:
+
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)
 
  seed(1)
Line 99: Line 96:
 
  scores.append(skill)
 
  scores.append(skill)
  
−
This is good for tutorials and demonstrations when the same result is needed every time your code is run.
+
Ini bagus untuk tutorial dan demonstrasi ketika hasil yang sama diperlukan setiap kali program kita dijalankan.
  
−
This is fragile and not recommended for evaluating models.
+
Ini fragile dan tidak direkomendasikan untuk mengevaluasi model.
  
 
See the post:
 
See the post:
Line 108: Line 105:
 
* How to Get Reproducible Results with Keras
 
* How to Get Reproducible Results with Keras
  
−
==Repeat Evaluation Experiments==
+
==Pengulangan Experimen Evaluasi==
  
−
A more robust approach is to repeat the experiment of evaluating a non-stochastic model multiple times.
+
Pendekatan yang lebih baik adalah mengulang percobaan mengevaluasi model non-stokastik beberapa kali.
−
 
+
Contoh:
−
For example:
 
  
 
  scores = list()
 
  scores = list()
Line 125: Line 121:
 
  scores.append(mean(run_scores))
 
  scores.append(mean(run_scores))
  
−
Note, we calculate the mean of the estimated mean model skill, the so-called grand mean.
+
Catatan, kita menghitung rata-rata perkiraan kemampuan rate-rata model, yang disebut grand mean.
  
−
This is my recommended procedure for estimating the skill of a deep learning model.
+
Berikut adalah saran cara memperkirakan kemampuan model deep learning.
  
−
Because repeats is often >=30, we can easily calculate the standard error of the mean model skill, which is how much the estimated mean of model skill score differs from the unknown actual mean model skill (e.g. how wrong mean_skill might be)
+
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))
 
  standard_error = standard_deviation / sqrt(count(scores))
  
−
Further, we can use the standard_error to calculate a confidence interval for mean_skill. This assumes that the distribution of the results is Gaussian, which you can check by looking at a Histogram, Q-Q plot, or using statistical tests on the collected 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.
  
−
For example, the interval of 95% is (1.96 * standard_error) around the mean skill.
+
Misalnya, interval 95% adalah (1,96 * standard_error) di sekitar kemampuan rata-rata.
  
 
  interval = standard_error * 1.96
 
  interval = standard_error * 1.96
Line 141: Line 137:
 
  upper_interval = mean_skill + interval
 
  upper_interval = mean_skill + interval
  
−
There are other perhaps more statistically robust methods for calculating confidence intervals than using the standard error of the grand mean, such as:
+
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.
 
* Calculating the Binomial proportion confidence interval.
 
* Using the bootstrap to estimate an empirical confidence interval.
 
* Using the bootstrap to estimate an empirical confidence interval.
  
−
==How Unstable Are Neural Networks?==
+
==Seberapa Tidak Stabilkah Neural Network?==
  
−
It depends on your problem, on the network, and on its configuration.
+
Itu tergantung pada masalah anda, pada jaringan, dan pada konfigurasinya.
  
−
I would recommend performing a sensitivity analysis to find out.
+
Sangat di sarankan untuk melakukan sensitivity analysis untuk mencari tahu.
  
−
Evaluate the same model on the same data many times (30, 100, or thousands) and only vary the seed for the random number generator.
+
Mengevaluasi model yang sama pada data yang sama berkali-kali (30, 100, atau ribuan) dan hanya memvariasikan seed untuk generator angka random.
  
−
Then review the mean and standard deviation of the skill scores produced. The standard deviation (average distance of scores from the mean score) will give you an idea of just how unstable your model is.
+
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.
−
How Many Repeats?
 
  
−
I would recommend at least 30, perhaps 100, even thousands, limited only by your time and computer resources, and diminishing returns (e.g. standard error on the mean_skill).
+
==Berapa Kali Repeat / Pengulangan?==
  
−
More rigorously, I would recommend an experiment that looked at the impact on estimated model skill versus the number of repeats and the calculation of the standard error (how much the mean estimated performance differs from the true underlying population mean).
+
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).
  
 
==Further Reading==
 
==Further Reading==
Line 171: Line 168:
 
==Summary==
 
==Summary==
  
−
In this post, you discovered how to evaluate the skill of deep learning models.
+
Dalam tulisan ini, kita menemukan cara mengevaluasi kemampuan deep learning model.
−
 
 
−
Specifically, you learned:
 
−
 
 
−
* The common mistake made by beginners when evaluating deep learning models.
 
−
* The rationale for using repeated k-fold cross validation to evaluate deep learning models.
 
−
* How to calculate related model skill statistics, such as standard deviation, standard error, and confidence intervals.
 
−
 
 
−
 
 
  
 +
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==
 
==Referensi==

Latest revision as of 18:41, 1 September 2019

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).

Further Reading

   Embrace Randomness in Machine Learning
   How to Train a Final Machine Learning Model
   Comparing Different Species of Cross-Validation
   Empirical Methods for Artificial Intelligence, Cohen, 1995.
   Standard error on Wikipedia

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

Pranala Menarik

Retrieved from "https://onnocenter.or.id/wiki/index.php?title=Keras:_Evaluate_the_Skill_of_Deep_Learning_Model&oldid=57027"