Kesalahan Validasi kurang dari kesalahan pelatihan?

Saya menemukan dua pertanyaan di sini dan di sini tentang masalah ini tetapi belum ada jawaban atau penjelasan yang jelas. Saya menegakkan masalah yang sama di mana kesalahan validasi kurang dari kesalahan pelatihan di Jaringan Neural Konvolusi saya. Apa artinya?

Sulit untuk memastikan tanpa mengetahui metodologi Anda yang sebenarnya (misalnya metode validasi silang, metrik kinerja, metode pemisahan data, dll.).

Secara umum, kesalahan pelatihan hampir selalu akan meremehkan kesalahan validasi Anda. Namun, kesalahan validasi mungkin kurang dari pelatihan. Anda dapat memikirkannya dua cara:

1. Set pelatihan Anda memiliki banyak kasus 'sulit' untuk dipelajari
2. Kumpulan validasi Anda memiliki sebagian besar kasus 'mudah' untuk diprediksi

Itulah mengapa penting bagi Anda untuk benar-benar mengevaluasi metodologi pelatihan model Anda. Jika Anda tidak membagi data untuk pelatihan dengan benar, hasil Anda akan mengarah pada kesimpulan yang membingungkan, jika tidak hanya salah.

Saya memikirkan evaluasi model dalam empat kategori berbeda:

1. Underfitting - Validasi dan kesalahan pelatihan tinggi

2. Overfitting - Kesalahan validasi tinggi, kesalahan pelatihan rendah

3. Cocok - Kesalahan validasi rendah, sedikit lebih tinggi dari kesalahan pelatihan

4. Kecocokan tidak dikenal - Kesalahan validasi rendah, kesalahan pelatihan 'tinggi'

Saya mengatakan 'tidak diketahui' cocok karena hasilnya berlawanan dengan cara kerja pembelajaran mesin. Inti dari ML adalah untuk memprediksi yang tidak diketahui. Jika Anda lebih baik dalam memprediksi hal yang tidak diketahui daripada yang telah Anda pelajari, AFAIK data antara pelatihan dan validasi harus berbeda dalam beberapa hal. Ini bisa berarti Anda perlu mengevaluasi kembali metode pemisahan data Anda, menambahkan lebih banyak data, atau mungkin mengubah metrik kinerja Anda (apakah Anda benar-benar mengukur kinerja yang Anda inginkan?).

SUNTING

Untuk mengatasi referensi OP ke pertanyaan python lasagne sebelumnya .

Ini menunjukkan bahwa Anda memiliki data yang memadai untuk tidak memerlukan validasi silang dan hanya memiliki pelatihan, validasi, dan pengujian himpunan bagian data. Sekarang, jika Anda melihat tutorial lasagna Anda dapat melihat bahwa perilaku yang sama terlihat di bagian atas halaman. Saya akan merasa sulit untuk percaya bahwa penulis akan memposting hasil seperti itu jika itu aneh tetapi alih-alih hanya dengan menganggap mereka benar mari kita lihat lebih jauh. Bagian yang paling menarik bagi kami di sini adalah di bagian loop pelatihan , tepat di atas bagian bawah Anda akan melihat bagaimana parameter kerugian dihitung.

The kerugian pelatihan dihitung atas seluruh dataset pelatihan . Demikian juga, kehilangan validasi dihitung atas seluruh dataset validasi . Set pelatihan biasanya setidaknya 4 kali lebih besar dari validasi (80-20). Mengingat bahwa kesalahan dihitung atas semua sampel, Anda dapat memperkirakan hingga sekitar 4X ukuran kerugian dari set validasi. Anda akan melihat, bagaimanapun, bahwa kehilangan pelatihan dan kehilangan validasi mendekati satu sama lain saat pelatihan berlanjut. Ini disengaja seolah-olah kesalahan pelatihan Anda mulai lebih rendah dari kesalahan validasi Anda, Anda akan mulai menyesuaikan model Anda !!!

Saya harap ini menjelaskan kesalahan ini.

Satu kemungkinan: Jika Anda menggunakan lapisan regularisasi dropout di jaringan Anda, masuk akal bahwa kesalahan validasi lebih kecil dari kesalahan pelatihan. Karena biasanya dropout diaktifkan ketika pelatihan tetapi dinonaktifkan ketika mengevaluasi pada set validasi. Anda mendapatkan fungsi yang lebih halus (biasanya berarti lebih baik) dalam kasus terakhir.

Saya tidak punya cukup poin untuk mengomentari jawaban @ DK, tetapi ini sekarang dijawab sebagai FAQ tentang dokumentasi Keras ':

"Mengapa kehilangan pelatihan jauh lebih tinggi daripada kehilangan pengujian?

Model Keras memiliki dua mode: pelatihan dan pengujian. Mekanisme pengaturan, seperti Dropout dan pengaturan berat L1 / L2, dimatikan pada saat pengujian.

Selain itu, kehilangan pelatihan adalah rata-rata dari kerugian atas setiap kumpulan data pelatihan. Karena model Anda berubah dari waktu ke waktu, kehilangan selama batch pertama dari suatu zaman umumnya lebih tinggi daripada selama batch terakhir. Di sisi lain, kerugian pengujian untuk zaman dihitung dengan menggunakan model seperti pada akhir zaman, menghasilkan kerugian yang lebih rendah. "

2 sen saya: Saya juga memiliki masalah yang sama bahkan tanpa memiliki lapisan putus sekolah. Dalam kasus saya - lapisan batch-norma adalah biang keladinya. Ketika saya menghapusnya - kehilangan pelatihan mirip dengan kehilangan validasi. Mungkin, itu terjadi karena selama pelatihan batch-norm menggunakan mean dan varians dari batch input yang diberikan, yang mungkin berbeda dari batch ke batch. Tetapi selama evaluasi, batch-norm menggunakan running mean dan variance, yang keduanya mencerminkan properti dari seluruh pelatihan yang ditetapkan jauh lebih baik daripada mean dan varians dari batch tunggal selama pelatihan. Setidaknya, begitulah batch-norma diimplementasikan di pytorch

Kemungkinan lain yang menggabungkan jawaban @cdeterman dan @DK dalam beberapa cara adalah jika Anda menggunakan beberapa mekanisme augmentasi data. Augmentasi data infact biasanya dilakukan hanya pada set pelatihan dan bukan pada set validasi (seperti untuk regularisasi putus), dan ini dapat menyebabkan set validasi yang berisi kasus "lebih mudah" untuk diprediksi daripada yang ada di set pelatihan.

Saya mendapat hasil yang sama (kehilangan tes secara signifikan lebih rendah dari kehilangan pelatihan). Begitu saya menghapus regularisasi dropout, kedua kerugiannya menjadi hampir sama.

@cdeterman dan @DK memiliki penjelasan yang bagus. Saya ingin satu alasan lagi - data leakage. Beberapa bagian dari data kereta Anda "terkait erat" dengan data uji.

Contoh potensial: bayangkan Anda memiliki 1000 anjing dan 1000 kucing dengan 500 gambar serupa per hewan peliharaan (beberapa pemilik suka memotret hewan peliharaan mereka dalam posisi yang sangat mirip), katakan di latar belakang. Jadi jika Anda melakukan split 70/30 acak, Anda akan mendapatkan data kebocoran data kereta ke dalam data uji.

Sederhananya, jika kehilangan pelatihan dan kehilangan validasi dihitung dengan benar, tidak mungkin kerugian pelatihan lebih tinggi dari kehilangan validasi. Ini karena back-propagation secara langsung mengurangi kesalahan yang dihitung pada set pelatihan dan hanya secara tidak langsung (bahkan tidak dijamin!) Mengurangi kesalahan yang dihitung pada set validasi.

Harus ada beberapa faktor tambahan yang berbeda saat pelatihan dan saat memvalidasi. Putus sekolah adalah yang baik, tetapi mungkin ada yang lain. Pastikan untuk memeriksa dokumentasi perpustakaan apa pun yang Anda gunakan. Model dan layer biasanya dapat memiliki pengaturan default yang biasanya tidak kita perhatikan.

Validasi yang lebih rendah daripada kesalahan pelatihan dapat disebabkan oleh fluktuasi yang terkait dengan dropout atau yang lain, tetapi jika itu bertahan dalam jangka panjang, ini mungkin mengindikasikan bahwa set data pelatihan dan validasi tidak benar-benar diambil dari ansambel statistik yang sama. Ini bisa terjadi jika contoh Anda berasal dari seri dan jika Anda tidak secara acak mengacak dataset pelatihan dan validasi.

Pada saat ini, metode berbasis gradien stokastik hampir selalu merupakan algoritma pilihan untuk pembelajaran yang mendalam. Ini berarti bahwa data datang sebagai kumpulan, gradien dihitung dan parameter diperbarui. Ini berarti Anda juga dapat menghitung kehilangan data karena setiap batch dipilih. Di bawah kerangka kerja ini, ada dua cara bagaimana kerugian dihitung yang dapat saya pikirkan yang dapat menyebabkan fenomena ini bahwa kesalahan pelatihan lebih besar daripada kesalahan validasi. Di bawah, saya menunjukkan bahwa Keras, pada kenyataannya, tampaknya menghitung kesalahan dalam sampel dengan cara-cara ini.

1.) Kesalahan pelatihan dirata-ratakan di seluruh zaman, dan sekaligus pada akhir zaman, tetapi kesalahan validasi hanya di akhir zaman. Perhatikan bahwa kesalahan validasi memiliki manfaat diperbarui sepenuhnya, sementara kesalahan pelatihan mencakup perhitungan kesalahan dengan lebih sedikit pembaruan. Tentu saja, asimptotik, efek ini umumnya harus menghilang.

2.) Kesalahan pelatihan dihitung sebelum pembaruan batch dilakukan. Dalam metode berbasis gradien stokastik, ada beberapa kebisingan gradien. Sementara seseorang mendaki bukit, ada kemungkinan besar bahwa seseorang mengurangi kerugian global yang dihitung atas semua sampel pelatihan. Namun, ketika seseorang menjadi sangat dekat dengan mode, arah pembaruan akan negatif sehubungan dengan sampel di batch Anda. Tapi karena kita terpental sekitar mode, ini berarti rata-rata kita harus memilih arah yang positif sehubungan dengan sampel yang keluardari batch. Sekarang, jika kita akan memperbarui sehubungan dengan sampel dalam batch yang diberikan, itu berarti mereka telah didorong oleh potensi banyak pembaruan batch yang mereka tidak termasuk, dengan menghitung kerugian mereka sebelum pembaruan, ini adalah saat stochastic metode telah mendorong parameter yang paling mendukung sampel lain dalam dataset Anda, sehingga memberi kami bias ke atas kecil dalam kerugian yang diharapkan.

Perhatikan bahwa sementara tanpa gejala, efek (1) hilang, (2) tidak! Di bawah ini saya menunjukkan bahwa Keras tampaknya melakukan keduanya (1) dan (2).

(1) Menunjukkan bahwa metrik dirata-rata pada setiap batch dalam zaman, bukan sekaligus pada akhir. Perhatikan perbedaan BESAR dalam akurasi sampel vs val_accuracy yang mendukung val_accuracy pada zaman pertama. Ini karena beberapa kesalahan dalam sampel dihitung dengan sedikit pembaruan batch.

>>> model.fit(Xtrn, Xtrn, epochs = 3, batch_size = 100, 
...                 validation_data = (Xtst, Xtst))
Train on 46580 samples, validate on 1000 samples
Epoch 1/3
46580/46580 [==============================] - 8s 176us/sample 
- loss: 0.2320 - accuracy: 0.9216 
- val_loss: 0.1581 - val_accuracy: 0.9636
Epoch 2/3
46580/46580 [==============================] - 8s 165us/sample 
- loss: 0.1487 - accuracy: 0.9662 
- val_loss: 0.1545 - val_accuracy: 0.9677
Epoch 3/3
46580/46580 [==============================] - 8s 165us/sample 
- loss: 0.1471 - accuracy: 0.9687 
- val_loss: 0.1424 - val_accuracy: 0.9699
<tensorflow.python.keras.callbacks.History object at 0x17070d080>

(2) Menampilkan kesalahan dihitung sebelum pembaruan untuk setiap batch. Perhatikan bahwa untuk zaman 1, ketika kami menggunakan batch_size = nRows(yaitu, semua data dalam satu kumpulan), kesalahan dalam sampel sekitar 0,5 (perkiraan acak) untuk zaman 1, namun kesalahan validasi adalah 0,82. Oleh karena itu, kesalahan dalam sampel dihitung sebelum pembaruan batch, sedangkan kesalahan validasi dihitung setelah pembaruan batch.

>>> model.fit(Xtrn, Xtrn, epochs = 3, batch_size = nRows, 
...                 validation_data = (Xtst, Xtst))
Train on 46580 samples, validate on 1000 samples
Epoch 1/3
46580/46580 [==============================] - 9s 201us/sample 
- loss: 0.7126 - accuracy: 0.5088 
- val_loss: 0.5779 - val_accuracy: 0.8191
Epoch 2/3
46580/46580 [==============================] - 6s 136us/sample 
- loss: 0.5770 - accuracy: 0.8211 
- val_loss: 0.4940 - val_accuracy: 0.8249
Epoch 3/3
46580/46580 [==============================] - 6s 120us/sample 
- loss: 0.4921 - accuracy: 0.8268 
- val_loss: 0.4502 - val_accuracy: 0.8249