इस समय, स्टोकेस्टिक ग्रेडिएंट आधारित विधियां लगभग हमेशा गहरी सीखने के लिए पसंद का एल्गोरिदम हैं। इसका अर्थ है कि डेटा बैचों के रूप में आता है, ग्रेडिएंट की गणना की जाती है और पैरामीटर अपडेट किए जाते हैं। इसका अर्थ यह है कि आप डेटा के नुकसान की गणना भी कर सकते हैं क्योंकि प्रत्येक बैच का चयन किया गया है। इस ढांचे के तहत, दो तरीके हैं कि कैसे नुकसान की गणना की जाती है जो मैं सोच सकता हूं कि इससे इस घटना को जन्म दे सकता है कि प्रशिक्षण त्रुटि सत्यापन त्रुटि से अधिक है। नीचे, मैं दिखाता हूं कि केरस वास्तव में, इन तरीकों से इन-सैंपल त्रुटियों की गणना करते दिखाई देते हैं।
1.) प्रशिक्षण की त्रुटि पूरे युग के दौरान औसतन होती है, बल्कि सभी एक बार युग के अंत में होती है, लेकिन सत्यापन त्रुटि केवल युग के अंत में होती है। ध्यान दें कि सत्यापन त्रुटि में पूरी तरह से अपडेट होने का लाभ है, जबकि प्रशिक्षण त्रुटि में कम अपडेट के साथ त्रुटि गणना शामिल है। बेशक, asymptotically यह प्रभाव आम तौर पर गायब हो जाना चाहिए।
2.) बैच अपडेट होने से पहले प्रशिक्षण त्रुटि की गणना की जाती है। स्टोकेस्टिक ग्रेडिएंट आधारित विधि में, कुछ शोर ढाल है। जबकि एक पहाड़ी पर चढ़ रहा है, वहाँ एक उच्च संभावना है कि सभी प्रशिक्षण नमूनों पर गणना की गई वैश्विक हानि कम हो रही है। हालांकि, जब कोई मोड के बहुत करीब पहुंच जाता है, तो आपके बैच में नमूनों के संबंध में अद्यतन दिशा नकारात्मक होगी । लेकिन जब से हम एक मोड के आसपास उछल रहे हैं, इसका मतलब है कि औसतन हमें एक ऐसी दिशा चुननी चाहिए जो नमूनों के संबंध में सकारात्मक होबैच के। अब, अगर हम दिए गए बैच में नमूनों के संबंध में अद्यतन करने वाले हैं, तो इसका मतलब है कि उन्हें संभावित रूप से कई बैच अपडेट द्वारा धक्का दिया गया है, जिसमें वे शामिल नहीं थे, अपडेट से पहले उनके नुकसान की गणना करके, यह तब है जब स्टोकेस्टिक तरीकों ने आपके डेटासेट में अन्य नमूनों के पक्ष में मापदंडों को सबसे अधिक धकेल दिया है, इस प्रकार हमें अपेक्षित नुकसान में एक छोटे से ऊपर वाला पूर्वाग्रह दे रहा है।
ध्यान दें कि asymptotically, का प्रभाव (1) चला जाता है, (2) नहीं! नीचे मैं दिखाता हूं कि केरस दोनों (1) और (2) करते दिखाई देते हैं।
(1) यह दिखाते हुए कि युग में प्रत्येक बैच पर मेट्रिक्स औसत हैं, बजाय एक बार अंत में। बहुत पहले के युग में val_accuracy के पक्ष में val_accuracy के इन-सैंपल सटीकता में बहुत बड़ा अंतर देखें। ऐसा इसलिए है क्योंकि बहुत कम बैच अपडेट के साथ कुछ इन-सैंपल एरर की गणना की जाती है।
>>> 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) त्रुटि दिखाना प्रत्येक बैच के लिए अद्यतन करने से पहले गणना की जाती है । ध्यान दें कि युगांतर 1 के लिए, जब हम उपयोग करते हैं batch_size = nRows(यानी, एक बैच में सभी डेटा), इन-नमूना त्रुटि epoch 1 के लिए लगभग 0.5 (यादृच्छिक अनुमान) है, फिर भी सत्यापन त्रुटि 0.82 है। इसलिए, बैच अद्यतन के पहले इन-सैंपल त्रुटि की गणना की गई थी , जबकि सत्यापन त्रुटि बैच अद्यतन के बाद गणना की गई थी ।
>>> 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