करेस की बैच नॉर्मलाइजेशन परत टूट गई है

• अप्रैल १, २०२४
• वासिलिस व्र्यनोटिस
• । 30 टिप्पणियाँ

अद्यतन: दुर्भाग्य से मेरा पेयर-रिक्वेस्ट टू केरस ने बदल दिया कि बैच सामान्यीकरण परत का व्यवहार स्वीकार नहीं किया गया था। आप विवरण पढ़ सकते हैं यहाँ उत्पन्न करें। उन लोगों के लिए जो कस्टम कार्यान्वयन के साथ गड़बड़ करने के लिए पर्याप्त बहादुर हैं, आप कोड पा सकते हैं मेरी शाखा। मैं इसे बनाए रख सकता हूं और इसे केरस के नवीनतम स्थिर संस्करण के साथ मर्ज कर सकता हूं (2.1.6, 2.2.2 और 2.2.4) जब तक मैं इसका उपयोग करता हूं, लेकिन कोई वादा नहीं करता।

डीप लर्निंग में काम करने वाले ज्यादातर लोगों ने या तो इस्तेमाल किया है या सुना है Keras। आपमें से जो नहीं हैं, उनके लिए यह एक महान पुस्तकालय है जो अंतर्निहित डीप लर्निंग चौखटे जैसे कि टेंसोरफ्लो, थीनो और सीएनटीके को सार करता है और एक प्रदान करता है उच्च स्तरीय एपीआई प्रशिक्षण के लिए ए.एन.एन. इसका उपयोग करना आसान है, तेजी से प्रोटोटाइप सक्षम बनाता है और इसमें एक अनुकूल सक्रिय समुदाय है। मैं इसका भारी उपयोग कर रहा हूं और परियोजना में समय-समय पर कुछ समय के लिए योगदान देता हूं और मैं निश्चित रूप से इसे किसी को भी सुझाता हूं जो डीप लर्निंग पर काम करना चाहता है।

भले ही केरस ने मेरे जीवन को आसान बना दिया, लेकिन कई बार मुझे बैच सामान्यीकरण परत के विषम व्यवहार से काट दिया गया है। समय के साथ इसका डिफ़ॉल्ट व्यवहार बदल गया है, फिर भी यह कई उपयोगकर्ताओं के लिए समस्या का कारण बनता है और परिणामस्वरूप कई संबंधित हैं खुले मामले गितूब पर। इस ब्लॉग पोस्ट में, मैं इस बात के लिए एक मामला बनाने की कोशिश करूंगा कि केरस की बैचैर्नाइजेशन लेयर ट्रांसफर लर्निंग के साथ अच्छा क्यों नहीं खेलता, मैं समस्या को ठीक करने वाला कोड प्रदान करूंगा और मैं इसके परिणामों के साथ उदाहरण दूंगा। पैच.

नीचे दिए गए उपखंडों पर, मैं एक परिचय प्रदान करता हूं कि डीप लर्निंग में ट्रांसफर लर्निंग का उपयोग कैसे किया जाता है, बैच सामान्यीकरण परत क्या है, कैसे learnining_phase काम करता है और कैसे केरस ने बीएन व्यवहार को समय के साथ बदल दिया। यदि आप पहले से ही ये जानते हैं, तो आप सीधे सेक्शन 2 में जा सकते हैं।

1.1 डीप लर्निंग के लिए ट्रांसफर लर्निंग का उपयोग करना महत्वपूर्ण है

डीप लर्निंग की अतीत में आलोचना करने के कारणों में से एक यह है कि इसके लिए बहुत अधिक डेटा की आवश्यकता होती है। यह हमेशा सही नहीं होता; इस सीमा को संबोधित करने के लिए कई तकनीकें हैं, जिनमें से एक है ट्रांसफर लर्निंग।

मान लें कि आप कंप्यूटर विज़न एप्लिकेशन पर काम कर रहे हैं और आप एक क्लासिफायर बनाना चाहते हैं जो बिल्लियों को कुत्तों से अलग करता है। आपको वास्तव में मॉडल को प्रशिक्षित करने के लिए लाखों बिल्ली / कुत्ते की छवियों की आवश्यकता नहीं है। इसके बजाय आप पूर्व-प्रशिक्षित क्लासिफ़ायर का उपयोग कर सकते हैं और कम डेटा के साथ शीर्ष संकल्पों को ठीक कर सकते हैं। इसके पीछे का विचार यह है कि चूंकि पूर्व-प्रशिक्षित मॉडल छवियों पर फिट था, इसलिए नीचे दिए गए कॉन्फोल्यूशन लाइनों, किनारों और अन्य उपयोगी पैटर्न जैसी विशेषताओं को पहचान सकते हैं, जिसका अर्थ है कि आप इसके भार का उपयोग कर सकते हैं या तो अच्छा इनिशियलाइज़ेशन मान या आंशिक रूप से अपने डेटा के साथ नेटवर्क को पुनः प्राप्त कर सकते हैं। ।

केरस कई पूर्व प्रशिक्षित मॉडल और आसान-से-सरल उदाहरणों के साथ आता है कि कैसे फाइन-ट्यून मॉडल हैं। आप पर अधिक पढ़ सकते हैं दस्तावेज़ीकरण.

1.2 बैच सामान्यीकरण परत क्या है?

2014 में Ioffe और Szegedy द्वारा बैच सामान्यीकरण परत पेश की गई थी। यह पिछली परत के आउटपुट को मानकीकृत करके गायब होने वाली ढाल समस्या को संबोधित करता है, यह आवश्यक पुनरावृत्तियों की संख्या को कम करके प्रशिक्षण को गति देता है और यह गहरे तंत्रिका नेटवर्क के प्रशिक्षण को सक्षम बनाता है। यह बताते हुए कि यह कैसे काम करता है, इस पोस्ट के दायरे से परे है, लेकिन मैं आपको इसे पढ़ने के लिए प्रोत्साहित करता हूं मूल पेपर। एक ओवरसाइम्प्लीफाइड स्पष्टीकरण यह है कि यह अपने मतलब को घटाकर और अपने मानक विचलन के साथ विभाजित करके इनपुट को बचाता है; यदि आवश्यक हो तो यह परिवर्तन को पूर्ववत करना भी सीख सकता है।

1.3 केरस में लर्निंग_पेज़ क्या है?

कुछ परतें प्रशिक्षण और इंजेक्शन मोड के दौरान अलग तरीके से काम करती हैं। सबसे सामान्य उदाहरण बैच सामान्यीकरण और ड्रॉपआउट परतें हैं। बीएन के मामले में, प्रशिक्षण के दौरान हम इनपुट को पुनर्विक्रय करने के लिए मिनी-बैच के माध्य और विचरण का उपयोग करते हैं। दूसरी ओर, अनुमान के दौरान हम चलती औसत और भिन्नता का उपयोग करते हैं जो प्रशिक्षण के दौरान अनुमान लगाया गया था।

केरस जानता है कि किस मोड में चलना है क्योंकि इसमें एक अंतर्निहित तंत्र है जिसे कहा जाता है Learning_phase। सीखने का चरण नियंत्रित करता है कि नेटवर्क ट्रेन या परीक्षण मोड पर है या नहीं। यदि यह उपयोगकर्ता द्वारा मैन्युअल रूप से सेट नहीं किया गया है, तो फिट होने के दौरान (नेटवर्क लर्निंग_पेज़ = 1 (ट्रेन मोड) के साथ चलता है। भविष्यवाणियों का निर्माण करते समय (उदाहरण के लिए, जब हम पूर्वानुमान () और मूल्यांकन () विधियों या फिट के सत्यापन चरण पर) कहते हैं, तो नेटवर्क Learning_phase = 0 (परीक्षण मोड) के साथ चलता है। भले ही इसकी अनुशंसा न की गई हो, लेकिन उपयोगकर्ता सीखे हुए_पेज़ को एक विशिष्ट मूल्य में सांख्यिकीय रूप से बदलने में सक्षम है, लेकिन ग्राफ़ में किसी भी मॉडल या टेंसर को जोड़ने से पहले ऐसा होना चाहिए। यदि Learning_phase स्टेटिक रूप से सेट किया गया है, तो केरेस को उपयोगकर्ता द्वारा चुने गए मोड में जो भी लॉक किया जाएगा।

1.4 समय के साथ केर ने बैच सामान्यीकरण कैसे लागू किया?

केरस ने कई बार बैच सामान्यीकरण के व्यवहार को बदल दिया है लेकिन सबसे हालिया महत्वपूर्ण अपडेट केरस 2.1.3 में हुआ है। V2.1.3 से पहले जब बीएन की परत जम गई थी (ट्रेन करने योग्य = गलत) यह अपने बैच के आँकड़ों को अद्यतन करता रहा, कुछ ऐसा जिसके कारण उसके उपयोगकर्ताओं को सिरदर्द हो गया।

यह सिर्फ एक अजीब नीति नहीं थी, यह वास्तव में गलत था। कल्पना कीजिए कि दृढ़ संकल्प के बीच एक बीएन परत मौजूद है; यदि परत जमी है तो उसमें कोई परिवर्तन नहीं होना चाहिए। यदि हम आंशिक रूप से इसके वज़न को अपडेट करते हैं और अगली परतें भी जमी हुई हैं, तो उन्हें मिनी-बैच के आंकड़ों के अपडेट को समायोजित करने का मौका कभी नहीं मिलेगा, जिससे उच्च त्रुटि हो सकती है। शुक्र है कि संस्करण 2.1.3 से शुरू होकर, जब एक बीएन परत जमी होती है, तो यह अपने आंकड़ों को अपडेट नहीं करता है। लेकिन क्या इतना ही काफी है? नहीं अगर आप Transfer Learning का उपयोग कर रहे हैं।

नीचे मैं बताता हूं कि वास्तव में क्या समस्या है और मैं इसे हल करने के लिए तकनीकी कार्यान्वयन को समाप्त करता हूं। मैं पहले और बाद में मॉडल की सटीकता पर प्रभाव दिखाने के लिए कुछ उदाहरण भी प्रदान करता हूं पैच लागू है।

2.1 समस्या का तकनीकी विवरण

केरस के वर्तमान कार्यान्वयन के साथ समस्या यह है कि जब एक बीएन परत जमी होती है, तो यह प्रशिक्षण के दौरान मिनी-बैच के आंकड़ों का उपयोग करना जारी रखता है। मेरा मानना ​​है कि जब बीएन जमे हुए होते हैं तो एक बेहतर तरीका होता है कि प्रशिक्षण के दौरान सीखे गए माध्य और विचरण का उपयोग करना। क्यों? उन्हीं कारणों से कि क्यों मिनी-बैच के आँकड़े को अपडेट नहीं किया जाना चाहिए जब परत जमी होती है: इससे खराब परिणाम हो सकते हैं क्योंकि अगली परतें ठीक से प्रशिक्षित नहीं होती हैं।

मान लें कि आप एक कंप्यूटर विज़न मॉडल का निर्माण कर रहे हैं, लेकिन आपके पास पर्याप्त डेटा नहीं है, इसलिए आप केरस के पूर्व-प्रशिक्षित सीएनएन में से एक का उपयोग करने का निर्णय लेते हैं और इसे ठीक करते हैं। दुर्भाग्य से, ऐसा करने से आपको कोई गारंटी नहीं मिलती है कि BN लेयर्स के अंदर आपके नए डेटासेट का माध्य और विचरण मूल डेटासेट के समान होगा। याद रखें कि प्रशिक्षण के दौरान, आपका नेटवर्क हमेशा मिनी-बैच आँकड़ों का उपयोग करेगा या तो बीएन परत जमी है या नहीं; आपत्ति के दौरान भी आप जमे हुए बीएन परतों के पहले से सीखे गए आँकड़ों का उपयोग करेंगे। नतीजतन, यदि आप शीर्ष परतों को फाइन-ट्यून करते हैं, तो उनके वजन को माध्य / विचरण के लिए समायोजित किया जाएगा नई डाटासेट। फिर भी, अनुमान के दौरान वे डेटा प्राप्त करेंगे जो कि स्केल किए गए हैं अलग ढंग से क्योंकि का मतलब / भिन्नता है मूल डेटासेट का उपयोग किया जाएगा।

ऊपर मैं प्रदर्शन उद्देश्यों के लिए एक सरलीकृत (और अवास्तविक) वास्तुकला प्रदान करता हूं। मान लेते हैं कि हम नेटवर्क के शीर्ष (दाएं तरफ) तक कन्वेंशन k + 1 से मॉडल को ठीक से ट्यून करते हैं और हम नीचे (बाएं तरफ) जमे हुए रहते हैं। प्रशिक्षण के दौरान 1 से k तक सभी बीएन लेयर आपके प्रशिक्षण डेटा के माध्य / विचरण का उपयोग करेंगे। जमे हुए ReLUs पर इसका नकारात्मक प्रभाव पड़ेगा यदि प्रत्येक बीएन पर माध्य और विचरण पूर्व प्रशिक्षण के दौरान सीखे गए लोगों के करीब नहीं हैं। यह बाकी नेटवर्क का भी कारण होगा (CONV k + 1 और बाद में) उन इनपुट के साथ प्रशिक्षित किया जाना चाहिए जिनके पास अलग-अलग तराजू हैं जो अनुमान के दौरान प्राप्त करेंगे। प्रशिक्षण के दौरान आपका नेटवर्क इन परिवर्तनों के अनुकूल हो सकता है, फिर भी जिस क्षण आप भविष्यवाणी-मोड पर जाते हैं, केरस विभिन्न मानकीकरण आँकड़ों का उपयोग करेगा, ऐसा कुछ जो घटिया परिणामों की ओर ले जाने वाली अगली परतों के आदानों के वितरण को तेज करेगा।

२.२ यदि आप प्रभावित होते हैं तो आप कैसे पता लगा सकते हैं?

इसका पता लगाने का एक तरीका यह है कि कैरस के सीखने के चरण को 1 (ट्रेन मोड) और 0 (टेस्ट मोड) पर सेट किया जाए और प्रत्येक मामले में आपके मॉडल का मूल्यांकन किया जाए। यदि समान डेटासेट पर सटीकता में महत्वपूर्ण अंतर है, तो आप समस्या से प्रभावित हो रहे हैं। यह इंगित करने के लायक है कि, जिस तरह से लर्निंग_पेज़ तंत्र केरस में लागू किया गया है, उसके कारण आमतौर पर इसके साथ गड़बड़ करने की सलाह नहीं दी जाती है। Learning_phase पर परिवर्तन का उन मॉडलों पर कोई प्रभाव नहीं पड़ेगा जो पहले से संकलित और उपयोग किए जाते हैं; जैसा कि आप अगले उपखंडों के उदाहरणों पर देख सकते हैं, ऐसा करने का सबसे अच्छा तरीका एक स्वच्छ सत्र के साथ शुरू करना है और ग्राफ़ में किसी भी टेंसर को परिभाषित करने से पहले Learning_phase को बदलना है।

बाइनरी क्लासिफायर के साथ काम करते समय समस्या का पता लगाने का एक और तरीका सटीकता और एयूसी की जांच करना है। यदि सटीकता 50% के करीब है, लेकिन एयूसी 1 के करीब है (और आप एक ही डेटासेट पर ट्रेन / टेस्ट मोड के बीच अंतर भी देखते हैं), तो यह हो सकता है कि बीएन आंकड़ों के कारण संभावनाएं आउट-ऑफ-स्केल हैं। इसी तरह, प्रतिगमन के लिए आप इसका पता लगाने के लिए एमएसई और स्पीयरमैन के सहसंबंध का उपयोग कर सकते हैं।

२.३ हम इसे कैसे ठीक कर सकते हैं?

मेरा मानना ​​है कि समस्या को ठीक किया जा सकता है अगर जमे हुए बीएन की परतें वास्तव में सिर्फ यही होती हैं: स्थायी रूप से परीक्षण मोड में बंद। कार्यान्वयन-वार, ट्रेन योग्य ध्वज को कम्प्यूटेशनल ग्राफ का हिस्सा होना चाहिए और बीएन के व्यवहार को न केवल Learning_phase पर बल्कि ट्रेन करने योग्य संपत्ति के मूल्य पर निर्भर करने की आवश्यकता है। आप मेरे कार्यान्वयन का विवरण पा सकते हैं Github.

उपरोक्त फिक्स को लागू करने से, जब एक बीएन परत जमी होती है, तो यह अब मिनी-बैच के आँकड़ों का उपयोग नहीं करेगा, बल्कि प्रशिक्षण के दौरान सीखे गए लोगों का उपयोग करेगा। नतीजतन, प्रशिक्षण और परीक्षण मोड के बीच कोई विसंगति नहीं होगी जो बढ़ती सटीकता की ओर ले जाती है। जाहिर है जब बीएन परत जमी नहीं है, तो यह प्रशिक्षण के दौरान मिनी-बैच के आंकड़ों का उपयोग करना जारी रखेगा।

2.4 पैच के प्रभावों का आकलन करना

भले ही मैंने हाल ही में उपरोक्त कार्यान्वयन लिखा था, इसके पीछे के विचार का वास्तविक रूप से विभिन्न वर्कअराउंड का उपयोग करने वाली दुनिया की समस्याओं पर बहुत अधिक परीक्षण किया गया है जो समान प्रभाव डालते हैं। उदाहरण के लिए, प्रशिक्षण और परीक्षण मोड के बीच की विसंगति और नेटवर्क को दो भागों में विभाजित करके (जमे हुए और अनफ़रोज़न) से बचा जा सकता है और कैश्ड प्रशिक्षण (एक बार जमे हुए मॉडल के माध्यम से डेटा पास करना और फिर उन्मुक्त नेटवर्क को प्रशिक्षित करने के लिए उनका उपयोग करना) किया जा सकता है। फिर भी, क्योंकि "मुझ पर विश्वास मैंने पहले किया है" आम तौर पर कोई वजन नहीं होता है, नीचे मैं कुछ उदाहरण प्रदान करता हूं जो अभ्यास में नए कार्यान्वयन के प्रभाव दिखाते हैं।

प्रयोग के बारे में कुछ महत्वपूर्ण बिंदु इस प्रकार हैं:

1. मैं जानबूझकर मॉडल को ओवरफिट करने के लिए डेटा की एक छोटी राशि का उपयोग करूंगा और उसी डेटासेट पर मॉडल को प्रशिक्षित और मान्य करूंगा। ऐसा करके, मैं ट्रेन / सत्यापन डेटासेट पर सटीक सटीकता और समान प्रदर्शन के पास की उम्मीद करता हूं।
2. यदि सत्यापन के दौरान मुझे समान डेटासेट पर काफी कम सटीकता प्राप्त होती है, तो मेरे पास स्पष्ट संकेत होगा कि वर्तमान बीएन नीति निष्कासन के दौरान मॉडल के प्रदर्शन को नकारात्मक रूप से प्रभावित करती है।
3. कोई भी प्रीप्रोसेसिंग जेनरेटरों के बाहर होगी। यह एक बग के आसपास काम करने के लिए किया जाता है जिसे v2.1.5 (वर्तमान में आगामी v2.1.6 और नवीनतम मास्टर पर तय) में पेश किया गया था।
4. हम मूल्यांकन के दौरान विभिन्न सीखने के चरणों का उपयोग करने के लिए केरस को मजबूर करेंगे। यदि हम सूचित सटीकता के बीच अंतर पाते हैं तो हम जानेंगे कि हम वर्तमान बीएन नीति से प्रभावित हैं।

प्रयोग के लिए कोड नीचे दिखाया गया है:

import numpy as np
from keras.datasets import cifar10
from scipy.misc import imresize

from keras.preprocessing.image import ImageDataGenerator
from keras.applications.resnet50 import ResNet50, preprocess_input
from keras.models import Model, load_model
from keras.layers import Dense, Flatten
from keras import backend as K


seed = 42
epochs = 10
records_per_class = 100

# We take only 2 classes from CIFAR10 and a very small sample to intentionally overfit the model.
# We will also use the same data for train/test and expect that Keras will give the same accuracy.
(x, y), _ = cifar10.load_data()

def filter_resize(category):
   # We do the preprocessing here instead in the Generator to get around a bug on Keras 2.1.5.
   return [preprocess_input(imresize(img, (224,224)).astype('float')) for img in x[y.flatten()==category][:records_per_class]]

x = np.stack(filter_resize(3)+filter_resize(5))
records_per_class = x.shape[0] // 2
y = np.array([[1,0]]*records_per_class + [[0,1]]*records_per_class)


# We will use a pre-trained model and finetune the top layers.
np.random.seed(seed)
base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
l = Flatten()(base_model.output)
predictions = Dense(2, activation='softmax')(l)
model = Model(inputs=base_model.input, outputs=predictions)

for layer in model.layers[:140]:
   layer.trainable = False

for layer in model.layers[140:]:
   layer.trainable = True

model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit_generator(ImageDataGenerator().flow(x, y, seed=42), epochs=epochs, validation_data=ImageDataGenerator().flow(x, y, seed=42))

# Store the model on disk
model.save('tmp.h5')


# In every test we will clear the session and reload the model to force Learning_Phase values to change.
print('DYNAMIC LEARNING_PHASE')
K.clear_session()
model = load_model('tmp.h5')
# This accuracy should match exactly the one of the validation set on the last iteration.
print(model.evaluate_generator(ImageDataGenerator().flow(x, y, seed=42)))


print('STATIC LEARNING_PHASE = 0')
K.clear_session()
K.set_learning_phase(0)
model = load_model('tmp.h5')
# Again the accuracy should match the above.
print(model.evaluate_generator(ImageDataGenerator().flow(x, y, seed=42)))


print('STATIC LEARNING_PHASE = 1')
K.clear_session()
K.set_learning_phase(1)
model = load_model('tmp.h5')
# The accuracy will be close to the one of the training set on the last iteration.
print(model.evaluate_generator(ImageDataGenerator().flow(x, y, seed=42)))

केरस v2.1.5 पर परिणाम देखें:

Epoch 1/10
1/7 [===>..........................] - ETA: 25s - loss: 0.8751 - acc: 0.5312
2/7 [=======>......................] - ETA: 11s - loss: 0.8594 - acc: 0.4531
3/7 [===========>..................] - ETA: 7s - loss: 0.8398 - acc: 0.4688 
4/7 [================>.............] - ETA: 4s - loss: 0.8467 - acc: 0.4844
5/7 [====================>.........] - ETA: 2s - loss: 0.7904 - acc: 0.5437
6/7 [========================>.....] - ETA: 1s - loss: 0.7593 - acc: 0.5625
7/7 [==============================] - 12s 2s/step - loss: 0.7536 - acc: 0.5744 - val_loss: 0.6526 - val_acc: 0.6650

Epoch 2/10
1/7 [===>..........................] - ETA: 4s - loss: 0.3881 - acc: 0.8125
2/7 [=======>......................] - ETA: 3s - loss: 0.3945 - acc: 0.7812
3/7 [===========>..................] - ETA: 2s - loss: 0.3956 - acc: 0.8229
4/7 [================>.............] - ETA: 1s - loss: 0.4223 - acc: 0.8047
5/7 [====================>.........] - ETA: 1s - loss: 0.4483 - acc: 0.7812
6/7 [========================>.....] - ETA: 0s - loss: 0.4325 - acc: 0.7917
7/7 [==============================] - 8s 1s/step - loss: 0.4095 - acc: 0.8089 - val_loss: 0.4722 - val_acc: 0.7700

Epoch 3/10
1/7 [===>..........................] - ETA: 4s - loss: 0.2246 - acc: 0.9375
2/7 [=======>......................] - ETA: 3s - loss: 0.2167 - acc: 0.9375
3/7 [===========>..................] - ETA: 2s - loss: 0.2260 - acc: 0.9479
4/7 [================>.............] - ETA: 2s - loss: 0.2179 - acc: 0.9375
5/7 [====================>.........] - ETA: 1s - loss: 0.2356 - acc: 0.9313
6/7 [========================>.....] - ETA: 0s - loss: 0.2392 - acc: 0.9427
7/7 [==============================] - 8s 1s/step - loss: 0.2288 - acc: 0.9456 - val_loss: 0.4282 - val_acc: 0.7800

Epoch 4/10
1/7 [===>..........................] - ETA: 4s - loss: 0.2183 - acc: 0.9688
2/7 [=======>......................] - ETA: 3s - loss: 0.1899 - acc: 0.9844
3/7 [===========>..................] - ETA: 2s - loss: 0.1887 - acc: 0.9792
4/7 [================>.............] - ETA: 1s - loss: 0.1995 - acc: 0.9531
5/7 [====================>.........] - ETA: 1s - loss: 0.1932 - acc: 0.9625
6/7 [========================>.....] - ETA: 0s - loss: 0.1819 - acc: 0.9688
7/7 [==============================] - 8s 1s/step - loss: 0.1743 - acc: 0.9747 - val_loss: 0.3778 - val_acc: 0.8400

Epoch 5/10
1/7 [===>..........................] - ETA: 3s - loss: 0.0973 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0828 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0851 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0897 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0928 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0936 - acc: 1.0000
7/7 [==============================] - 8s 1s/step - loss: 0.1337 - acc: 0.9838 - val_loss: 0.3916 - val_acc: 0.8100

Epoch 6/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0747 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0852 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0812 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0831 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0779 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0766 - acc: 1.0000
7/7 [==============================] - 8s 1s/step - loss: 0.0813 - acc: 1.0000 - val_loss: 0.3637 - val_acc: 0.8550

Epoch 7/10
1/7 [===>..........................] - ETA: 1s - loss: 0.2478 - acc: 0.8750
2/7 [=======>......................] - ETA: 2s - loss: 0.1966 - acc: 0.9375
3/7 [===========>..................] - ETA: 2s - loss: 0.1528 - acc: 0.9583
4/7 [================>.............] - ETA: 1s - loss: 0.1300 - acc: 0.9688
5/7 [====================>.........] - ETA: 1s - loss: 0.1193 - acc: 0.9750
6/7 [========================>.....] - ETA: 0s - loss: 0.1196 - acc: 0.9792
7/7 [==============================] - 8s 1s/step - loss: 0.1084 - acc: 0.9838 - val_loss: 0.3546 - val_acc: 0.8600

Epoch 8/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0539 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.0900 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0815 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0740 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0700 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0701 - acc: 1.0000
7/7 [==============================] - 8s 1s/step - loss: 0.0695 - acc: 1.0000 - val_loss: 0.3269 - val_acc: 0.8600

Epoch 9/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0306 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0377 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0898 - acc: 0.9583
4/7 [================>.............] - ETA: 1s - loss: 0.0773 - acc: 0.9688
5/7 [====================>.........] - ETA: 1s - loss: 0.0742 - acc: 0.9750
6/7 [========================>.....] - ETA: 0s - loss: 0.0708 - acc: 0.9792
7/7 [==============================] - 8s 1s/step - loss: 0.0659 - acc: 0.9838 - val_loss: 0.3604 - val_acc: 0.8600

Epoch 10/10
1/7 [===>..........................] - ETA: 3s - loss: 0.0354 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0381 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0354 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0828 - acc: 0.9688
5/7 [====================>.........] - ETA: 1s - loss: 0.0791 - acc: 0.9750
6/7 [========================>.....] - ETA: 0s - loss: 0.0794 - acc: 0.9792
7/7 [==============================] - 8s 1s/step - loss: 0.0704 - acc: 0.9838 - val_loss: 0.3615 - val_acc: 0.8600

DYNAMIC LEARNING_PHASE
[0.3614931714534759, 0.86]

STATIC LEARNING_PHASE = 0
[0.3614931714534759, 0.86]

STATIC LEARNING_PHASE = 1
[0.025861846953630446, 1.0]

जैसा कि हम ऊपर देख सकते हैं, प्रशिक्षण के दौरान मॉडल बहुत अच्छी तरह से डेटा सीखता है और प्रशिक्षण सेट पर सटीक सटीकता के साथ प्राप्त होता है। अभी भी प्रत्येक पुनरावृत्ति के अंत में, समान डेटासेट पर मॉडल का मूल्यांकन करते समय, हमें नुकसान और सटीकता में महत्वपूर्ण अंतर मिलता है। ध्यान दें कि हमें यह नहीं मिलना चाहिए; हमने विशिष्ट डेटासेट पर जानबूझकर मॉडल को ओवरफिट किया है और प्रशिक्षण / सत्यापन डेटासेट समान हैं।

प्रशिक्षण पूरा होने के बाद हम 3 विभिन्न लर्निंग_पेज़ कॉन्फ़िगरेशन का उपयोग करके मॉडल का मूल्यांकन करते हैं: डायनेमिक, स्टेटिक = 0 (टेस्ट मोड) और स्टेटिक = 1 (ट्रेनिंग मोड)। जैसा कि हम देख सकते हैं कि पहले दो विन्यास नुकसान और सटीकता के संदर्भ में समान परिणाम प्रदान करेंगे और उनके मूल्य पिछले पुनरावृत्ति में निर्धारित सत्यापन पर मॉडल की रिपोर्ट की सटीकता से मेल खाते हैं। फिर भी, एक बार जब हम प्रशिक्षण मोड में चले जाते हैं, तो हम एक बड़े पैमाने पर विसंगति (सुधार) का निरीक्षण करते हैं। ऐसा क्यों? जैसा कि हमने पहले कहा, नेटवर्क के वजन को प्रशिक्षण डेटा के माध्य / विचरण के साथ स्केल किए गए डेटा को प्राप्त करने की उम्मीद है। दुर्भाग्य से, वे आँकड़े बीएन परतों में संग्रहीत वाले से अलग हैं। चूंकि बीएन की परतें जमी हुई थीं, इसलिए ये आँकड़े कभी भी अपडेट नहीं किए गए थे। बीएन आँकड़ों के मूल्यों के बीच यह विसंगति अनुमान के दौरान सटीकता की गिरावट की ओर जाता है।

आइए देखें कि एक बार हम क्या लागू करते हैं पैच:

Epoch 1/10
1/7 [===>..........................] - ETA: 26s - loss: 0.9992 - acc: 0.4375
2/7 [=======>......................] - ETA: 12s - loss: 1.0534 - acc: 0.4375
3/7 [===========>..................] - ETA: 7s - loss: 1.0592 - acc: 0.4479 
4/7 [================>.............] - ETA: 4s - loss: 0.9618 - acc: 0.5000
5/7 [====================>.........] - ETA: 2s - loss: 0.8933 - acc: 0.5250
6/7 [========================>.....] - ETA: 1s - loss: 0.8638 - acc: 0.5417
7/7 [==============================] - 13s 2s/step - loss: 0.8357 - acc: 0.5570 - val_loss: 0.2414 - val_acc: 0.9450

Epoch 2/10
1/7 [===>..........................] - ETA: 4s - loss: 0.2331 - acc: 0.9688
2/7 [=======>......................] - ETA: 2s - loss: 0.3308 - acc: 0.8594
3/7 [===========>..................] - ETA: 2s - loss: 0.3986 - acc: 0.8125
4/7 [================>.............] - ETA: 1s - loss: 0.3721 - acc: 0.8281
5/7 [====================>.........] - ETA: 1s - loss: 0.3449 - acc: 0.8438
6/7 [========================>.....] - ETA: 0s - loss: 0.3168 - acc: 0.8646
7/7 [==============================] - 9s 1s/step - loss: 0.3165 - acc: 0.8633 - val_loss: 0.1167 - val_acc: 0.9950

Epoch 3/10
1/7 [===>..........................] - ETA: 1s - loss: 0.2457 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.2592 - acc: 0.9688
3/7 [===========>..................] - ETA: 2s - loss: 0.2173 - acc: 0.9688
4/7 [================>.............] - ETA: 1s - loss: 0.2122 - acc: 0.9688
5/7 [====================>.........] - ETA: 1s - loss: 0.2003 - acc: 0.9688
6/7 [========================>.....] - ETA: 0s - loss: 0.1896 - acc: 0.9740
7/7 [==============================] - 9s 1s/step - loss: 0.1835 - acc: 0.9773 - val_loss: 0.0678 - val_acc: 1.0000

Epoch 4/10
1/7 [===>..........................] - ETA: 1s - loss: 0.2051 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.1652 - acc: 0.9844
3/7 [===========>..................] - ETA: 2s - loss: 0.1423 - acc: 0.9896
4/7 [================>.............] - ETA: 1s - loss: 0.1289 - acc: 0.9922
5/7 [====================>.........] - ETA: 1s - loss: 0.1225 - acc: 0.9938
6/7 [========================>.....] - ETA: 0s - loss: 0.1149 - acc: 0.9948
7/7 [==============================] - 9s 1s/step - loss: 0.1060 - acc: 0.9955 - val_loss: 0.0455 - val_acc: 1.0000

Epoch 5/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0769 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.0846 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0797 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0736 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0914 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0858 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0808 - acc: 1.0000 - val_loss: 0.0346 - val_acc: 1.0000

Epoch 6/10
1/7 [===>..........................] - ETA: 1s - loss: 0.1267 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.1039 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0893 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0780 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0758 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0789 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0738 - acc: 1.0000 - val_loss: 0.0248 - val_acc: 1.0000

Epoch 7/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0344 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0385 - acc: 1.0000
3/7 [===========>..................] - ETA: 3s - loss: 0.0467 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0445 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0446 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0429 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0421 - acc: 1.0000 - val_loss: 0.0202 - val_acc: 1.0000

Epoch 8/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0319 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0300 - acc: 1.0000
3/7 [===========>..................] - ETA: 3s - loss: 0.0320 - acc: 1.0000
4/7 [================>.............] - ETA: 2s - loss: 0.0307 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0303 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0291 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0358 - acc: 1.0000 - val_loss: 0.0167 - val_acc: 1.0000

Epoch 9/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0246 - acc: 1.0000
2/7 [=======>......................] - ETA: 3s - loss: 0.0255 - acc: 1.0000
3/7 [===========>..................] - ETA: 3s - loss: 0.0258 - acc: 1.0000
4/7 [================>.............] - ETA: 2s - loss: 0.0250 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0252 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0260 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0327 - acc: 1.0000 - val_loss: 0.0143 - val_acc: 1.0000

Epoch 10/10
1/7 [===>..........................] - ETA: 4s - loss: 0.0251 - acc: 1.0000
2/7 [=======>......................] - ETA: 2s - loss: 0.0228 - acc: 1.0000
3/7 [===========>..................] - ETA: 2s - loss: 0.0217 - acc: 1.0000
4/7 [================>.............] - ETA: 1s - loss: 0.0249 - acc: 1.0000
5/7 [====================>.........] - ETA: 1s - loss: 0.0244 - acc: 1.0000
6/7 [========================>.....] - ETA: 0s - loss: 0.0239 - acc: 1.0000
7/7 [==============================] - 9s 1s/step - loss: 0.0290 - acc: 1.0000 - val_loss: 0.0127 - val_acc: 1.0000

DYNAMIC LEARNING_PHASE
[0.012697912137955427, 1.0]

STATIC LEARNING_PHASE = 0
[0.012697912137955427, 1.0]

STATIC LEARNING_PHASE = 1
[0.01744014158844948, 1.0]

सबसे पहले, हम देखते हैं कि नेटवर्क काफी तेजी से परिवर्तित होता है और पूर्ण सटीकता प्राप्त करता है। हम यह भी देखते हैं कि जब हम विभिन्न learning_phase मानों के बीच स्विच करते हैं, तो सटीकता के मामले में कोई विसंगति नहीं होती है।

2.5 असली डेटासेट पर पैच कैसा प्रदर्शन करता है?

तो पैच एक अधिक यथार्थवादी प्रयोग पर कैसे करता है? आइए केआरएस के पूर्व-प्रशिक्षित रेसनेट 50 (मूल रूप से कल्पना पर फिट) का उपयोग करें, शीर्ष वर्गीकरण परत को हटा दें और पैच के साथ और इसके बिना इसे ठीक करें और परिणामों की तुलना करें। डेटा के लिए, हम CIFAR10 (केरस द्वारा प्रदान की जाने वाली मानक ट्रेन / परीक्षण विभाजन) का उपयोग करेंगे और हम ResNet224 के इनपुट आकार के साथ संगत बनाने के लिए छवियों को 224 × 50 में बदल देंगे।

हम RSMprop का उपयोग करके शीर्ष वर्गीकरण परत को प्रशिक्षित करने के लिए 10 युगों करेंगे और फिर हम 5 के बाद सब कुछ ठीक कर देंगे 139 वीं परत के बाद सब्ज़ का उपयोग करके (lr = 1e-4, गति = 0.9)। पैच के बिना हमारा मॉडल 87.44% की सटीकता प्राप्त करता है। पैच का उपयोग करके, हम 92.36% की सटीकता प्राप्त करते हैं, लगभग 5 अंक अधिक।

२.६ क्या हमें ड्रॉपआउट जैसी अन्य परतों के लिए भी यही तय करना चाहिए?

बैच नॉर्मलाइज़ेशन एकमात्र परत नहीं है जो ट्रेन और परीक्षण मोड के बीच अलग-अलग संचालित होती है। ड्रॉपआउट और इसके वेरिएंट पर भी समान प्रभाव पड़ता है। क्या हमें इन सभी परतों पर समान नीति लागू करनी चाहिए? मुझे विश्वास है कि नहीं (भले ही मुझे इस पर आपके विचार सुनना अच्छा लगेगा)। कारण यह है कि ड्रॉपआउट का उपयोग ओवरफिटिंग से बचने के लिए किया जाता है, इस प्रकार प्रशिक्षण के दौरान इसे स्थायी रूप से भविष्यवाणी मोड में बंद कर दिया जाता है। तुम क्या सोचते हो?

मेरा दृढ़ता से मानना ​​है कि इस विसंगति का समाधान केरस में होना चाहिए। मैंने इस समस्या के कारण वास्तविक दुनिया के अनुप्रयोगों में और भी अधिक गहरा प्रभाव (100% से 50% सटीकता तक) देखा है। मैं भेजने की योजना पहले से ही एक भेजा PR करेस के साथ फिक्स और उम्मीद है कि इसे स्वीकार कर लिया जाएगा।

अगर आपको यह ब्लॉगपोस्ट पसंद आया है, तो कृपया इसे फेसबुक या ट्विटर पर साझा करने के लिए एक क्षण ले लें। 🙂