रूसी में पूरा पाठ्यक्रम इस लिंक पर पाया जा सकता है।
इस लिंक पर मूल अंग्रेजी पाठ्यक्रम उपलब्ध है।

हर 2-3 दिनों में नए व्याख्यान निर्धारित होते हैं।

सामग्री

सेबस्टियन ट्रन के साथ साक्षात्कार
परिचय
कुत्तों और बिल्लियों डेटासैट
विभिन्न आकारों की छवियाँ
रंग छवियों। भाग 1
रंग छवियों। भाग २
रंग छवियों पर बातचीत ऑपरेशन
रंग छवियों में अधिकतम मूल्य से सबसम्पलिंग का संचालन
कोलैब: बिल्लियों और कुत्तों
सॉफ्टमैक्स और सिग्मॉइड
निरीक्षण
छवि विस्तार
अपवाद
CoLab: कुत्तों और बिल्लियों। दुहराव
मुंहतोड़ जवाब देने के लिए अन्य तकनीकें
व्यायाम: रंग छवि वर्गीकरण
परिणाम

सॉफ्टमैक्स और सिगमॉइड

अपने आखिरी हाथों में कोलैब पर, हमने निम्नलिखित दृढ़ तंत्रिका नेटवर्क वास्तुकला का उपयोग किया:

model = tf.keras.models.Sequential([ tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(150, 150, 3)), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(64, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(128, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(128, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Flatten(), tf.keras.layers.Dense(512, activation='relu'), tf.keras.layers.Dense(2, activation='softmax') ])

कृपया ध्यान दें कि हमारी अंतिम परत (हमारे क्लासिफायरियर) में दो आउटपुट न्यूरॉन्स और softmax सक्रियण softmax साथ पूरी तरह से जुड़ी परत शामिल है:

 tf.keras.layers.Dense(2, activation='softmax')

बाइनरी वर्गीकरण की समस्याओं को हल करने के लिए एक और लोकप्रिय दृष्टिकोण एक क्लासिफायरियर का उपयोग है, जिसमें 1 आउटपुट न्यूरॉन और sigmoid सक्रियण sigmoid साथ पूरी तरह से जुड़ा हुआ परत शामिल sigmoid :

 tf.keras.layers.Dense(1, activation='sigmoid')

ये दोनों विकल्प बाइनरी वर्गीकरण समस्या में अच्छी तरह से काम करेंगे। हालाँकि, आपको क्या ध्यान में रखना चाहिए यदि आप अपने क्लासिफायर में sigmoid सक्रियण sigmoid का उपयोग करने का निर्णय लेते हैं, तो आपको नीचे दिए गए उदाहरण के रूप में binary_crossentropy sparse_categorical_crossentropy से binary_crossentropy में sparse_categorical_crossentropy model.compile() विधि में नुकसान फ़ंक्शन को बदलने की आवश्यकता होगी।

 model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

मान्यता

पिछली कक्षाओं में, हमने एक परीक्षण डेटासेट पर accuracy मीट्रिक का उपयोग करते हुए हमारे दृढ़ तंत्रिका नेटवर्क की सटीकता का अध्ययन किया। जब हमने फैशन MNIST डेटा सेट से छवियों को वर्गीकृत करने के लिए एक दृढ़ तंत्रिका नेटवर्क विकसित किया, तो हमने प्रशिक्षण डेटा सेट पर 97% सटीकता और परीक्षण डेटा सेट पर केवल 92% सटीकता प्राप्त की। यह सब इसलिए हुआ क्योंकि हमारा मॉडल पीछे हट गया था। दूसरे शब्दों में, हमारा दृढ़ तंत्रिका नेटवर्क प्रशिक्षण डेटा सेट को याद रखना शुरू कर रहा था। हालाँकि, हम प्रशिक्षण डेटा सेट की सटीकता और परीक्षण डेटा सेट की तुलना करके उपलब्ध डेटा पर मॉडल का परीक्षण और परीक्षण करने के बाद ही फिर से सीखने के बारे में जानने में सक्षम थे।

इस समस्या से बचने के लिए, हम अक्सर सत्यापन के लिए डेटा सेट का उपयोग करते हैं:

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

विचार यह है कि चूंकि हम मॉडल को प्रशिक्षित करते समय सत्यापन डेटा सेट का उपयोग नहीं करते हैं, तो सत्यापन सेट पर मॉडल का परीक्षण करने से हमें यह समझने की अनुमति मिलेगी कि मॉडल पीछे हट गया है या नहीं।

आइए एक उदाहरण देखें।

CoLab में, जो हमने कुछ बिंदुओं के ऊपर प्रदर्शन किया, हमने अपने तंत्रिका नेटवर्क को 15 पुनरावृत्तियों के लिए प्रशिक्षित किया।

 Epoch 15/15 10/10 [===] - loss: 1.0124 - acc: 0.7170 20/20 [===] - loss: 0.0528 - acc: 0.9900 - val_loss: 1.0124 - val_acc: 0.7070

यदि हम पंद्रहवें प्रशिक्षण पुनरावृत्ति में प्रशिक्षण और सत्यापन डेटा सेट पर भविष्यवाणियों की सटीकता को देखते हैं, तो हम देख सकते हैं कि हमने प्रशिक्षण डेटा सेट पर उच्च सटीकता और सत्यापन डेटा सेट पर काफी कम संकेतक प्राप्त किया है - 0.9900 बनाम 0.7070 ।

यह मुंहतोड़ जवाब देने का एक स्पष्ट संकेत है। तंत्रिका नेटवर्क ने प्रशिक्षण डेटा सेट को याद किया, इसलिए यह उससे इनपुट डेटा पर अविश्वसनीय सटीकता के साथ काम करता है। हालांकि, जैसे ही एक सत्यापन डेटासेट पर सटीकता की जांच करने की बात आती है कि मॉडल ने "नहीं" देखा, परिणाम काफी कम हो गए हैं।

सभी प्रकार के प्रशिक्षण पुनरावृत्तियों में प्रशिक्षण और सत्यापन डेटा सेट पर नुकसान फ़ंक्शन के मानों के ग्राफ का सावधानीपूर्वक अध्ययन करने से बचने का एक तरीका है:

CoLab में, हमने एक समान ग्राफ बनाया और प्रशिक्षण पुनरावृत्ति पर नुकसान फ़ंक्शन की निर्भरता के उपरोक्त ग्राफ के समान कुछ मिला।

आप देख सकते हैं कि एक निश्चित प्रशिक्षण पुनरावृत्ति के बाद, सत्यापन डेटा सेट में नुकसान फ़ंक्शन का मूल्य बढ़ना शुरू हो जाता है, जबकि प्रशिक्षण डेटा सेट में नुकसान फ़ंक्शन का मूल्य घटता रहता है।

15 प्रशिक्षण पुनरावृत्ति के अंत में, हम देखते हैं कि सत्यापन डेटा सेट पर नुकसान फ़ंक्शन का मूल्य बहुत अधिक है, और प्रशिक्षण डेटा सेट पर नुकसान फ़ंक्शन का मूल्य बहुत छोटा है। दरअसल, यह न्यूरल नेटवर्क रिट्रेनिंग का बहुत संकेतक है।

ग्राफ को ध्यान से देखने पर, आप समझ सकते हैं कि शाब्दिक रूप से कुछ प्रशिक्षण पुनरावृत्तियों के बाद, हमारा तंत्रिका नेटवर्क केवल प्रशिक्षण डेटा संग्रहीत करना शुरू करता है, जिसका अर्थ है कि मॉडल की सामान्यीकरण की क्षमता कम हो जाती है, जिससे सत्यापन डेटा सेट पर सटीकता में गिरावट होती है।

जैसा कि आप शायद पहले से ही समझते हैं, सत्यापन डेटा सेट हमें प्रशिक्षण पुनरावृत्तियों की संख्या निर्धारित करने की अनुमति देता है जो कि करने की आवश्यकता है ताकि हमारा दृढ़ तंत्रिका नेटवर्क सटीक हो और, एक ही समय में, फिर से न चले।

इस तरह का एक दृष्टिकोण अत्यंत उपयोगी हो सकता है, अगर हमारे पास विभिन्न तंत्रिका नेटवर्क के कई आर्किटेक्चर का विकल्प हो:

उदाहरण के लिए, यदि आप एक दृढ़ तंत्रिका नेटवर्क में परतों की संख्या पर निर्णय लेते हैं, तो आप तंत्रिका नेटवर्क के कई आर्किटेक्चर बना सकते हैं और फिर सत्यापन के लिए डेटा सेट का उपयोग करके उनकी सटीकता की तुलना कर सकते हैं।

तंत्रिका नेटवर्क की वास्तुकला, जो आपको नुकसान फ़ंक्शन के न्यूनतम मूल्य को प्राप्त करने की अनुमति देती है और आपके कार्य को हल करने के लिए सबसे अच्छा होगा।

अगला सवाल जो आपके पास हो सकता है, अगर हमारे पास पहले से ही एक परीक्षण डेटासेट है, तो एक सत्यापन डेटासेट क्यों बनाएं? क्या हम सत्यापन के लिए परीक्षण डेटा सेट का उपयोग कर सकते हैं?

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

यह इस कारण से है कि हमें एक सत्यापन डेटासेट की आवश्यकता है जिसे हमारे मॉडल ने अपने प्रदर्शन को सही ढंग से सत्यापित करने के लिए पहले कभी नहीं देखा है।

हमने अभी पता लगाया है कि कैसे एक वैध डेटासेट हमें वापस लेने से बचने में मदद कर सकता है। निम्नलिखित हिस्सों में, हम डेटा विस्तार (तथाकथित वृद्धि) और न्यूरॉन्स के वियोग (तथाकथित ड्रॉपआउट) के बारे में बात करेंगे - दो लोकप्रिय तकनीकें जो हमें फिर से शिक्षित करने से बचने में भी मदद कर सकती हैं।

छवि विस्तार (वृद्धि)

एक निश्चित वर्ग की वस्तुओं को निर्धारित करने के लिए तंत्रिका नेटवर्क के प्रशिक्षण में, हम चाहते हैं कि हमारा तंत्रिका नेटवर्क इन वस्तुओं को ढूंढे, भले ही उनका स्थान और आकार छवि में हो।

उदाहरण के लिए, मान लें कि हम अपने तंत्रिका नेटवर्क को चित्रों में कुत्तों को पहचानने के लिए प्रशिक्षित करना चाहते हैं:

इस प्रकार, हम चाहते हैं कि हमारा तंत्रिका नेटवर्क छवि में कुत्ते की उपस्थिति का निर्धारण करे, भले ही कुत्ता कितना बड़ा हो और छवि के किस हिस्से में हो, चाहे कुत्ते का हिस्सा दिखाई दे या पूरा कुत्ता। हम यह सुनिश्चित करना चाहते हैं कि हमारा तंत्रिका नेटवर्क प्रशिक्षण के दौरान इन सभी विकल्पों को संसाधित कर सकता है।

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

इस समस्या को "एक्सटेंशन" (छवि वृद्धि) नामक तकनीक का उपयोग करके हल किया जा सकता है। प्रशिक्षण सेट से छवियों के मूल सेट के मनमाने ढंग से परिवर्तनों को लागू करके प्रशिक्षण के लिए नई छवियां बनाकर (उत्पन्न करके) छवियों का विस्तार (डेटा) काम करता है।

उदाहरण के लिए, हम अपने प्रशिक्षण डेटासेट से स्रोत छवियों में से एक ले सकते हैं और इसके लिए कई मनमाने ढंग से परिवर्तन लागू कर सकते हैं - इसे एक्स डिग्री से मिरर करें, क्षैतिज रूप से मिरर करें और एक मनमाना वृद्धि करें।

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

अगले भाग में, हम सीखेंगे कि एक ड्रॉपआउट (शटडाउन) क्या है - एक मॉडल को ओवरफिट करने से रोकने के लिए एक और तकनीक।

अपवाद (ड्रॉपआउट)

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

एक समस्या जो तंत्रिका नेटवर्क को प्रशिक्षित करते समय सामने आ सकती है वह है तंत्रिका नेटवर्क के एक हिस्से में विशाल मूल्य और तंत्रिका नेटवर्क के दूसरे भाग में छोटे मूल्य।

नतीजतन, यह पता चला है कि उच्च भार वाले न्यूरॉन्स सीखने की प्रक्रिया में अधिक भूमिका निभाते हैं, जबकि कम वजन वाले न्यूरॉन्स महत्वपूर्ण होने के लिए संघर्ष करते हैं और परिवर्तन के लिए कम और कम होते हैं। इससे बचने का एक तरीका है, न्यूरॉन्स की मनमानी ड्रॉपआउट का उपयोग करना।

शटडाउन (ड्रॉपआउट) - सीखने की प्रक्रिया में न्यूरॉन्स के चयनात्मक बंद होने की प्रक्रिया।

सीखने की प्रक्रिया में कुछ न्यूरॉन्स के चयनात्मक शटडाउन आपको सीखने में अन्य न्यूरॉन्स को सक्रिय रूप से संलग्न करने की अनुमति देता है। प्रशिक्षण पुनरावृत्तियों के दौरान, हम मनमाने ढंग से कुछ न्यूरॉन्स को अक्षम करते हैं।

आइए एक उदाहरण देखें। कल्पना कीजिए कि पहली प्रशिक्षण यात्रा में, हम काले रंग में हाइलाइट किए गए दो न्यूरॉन्स को बंद करते हैं:

प्रत्यक्ष प्रसार और वापस प्रसार की प्रक्रिया पृथक दो न्यूरॉन्स के उपयोग के बिना होती है।

दूसरे प्रशिक्षण पुनरावृत्ति पर, हम निम्नलिखित तीन न्यूरॉन्स का उपयोग नहीं करने का निर्णय लेते हैं - उन्हें बंद करें:

जैसा कि पिछले मामले में, प्रत्यक्ष और रिवर्स प्रसार की प्रक्रियाओं में, हम इन तीन न्यूरॉन्स का उपयोग नहीं करते हैं। अंतिम, तीसरे प्रशिक्षण पुनरावृत्ति पर, हम इन दो न्यूरॉन्स का उपयोग नहीं करने का निर्णय लेते हैं:

और इस मामले में, हम प्रत्यक्ष और रिवर्स प्रसार की प्रक्रियाओं में डिस्कनेक्ट न्यूरॉन्स का उपयोग नहीं करते हैं। और इसी तरह।

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

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

अब व्यवहार में प्राप्त सैद्धांतिक ज्ञान को लागू करते हैं और बिल्लियों और कुत्तों की छवियों के हमारे वर्गीकरण को परिष्कृत करते हैं।

CoLab: कुत्तों और बिल्लियों। दुहराव

अंग्रेजी में CoLab इस लिंक पर उपलब्ध है।
इस लिंक पर रूसी में कोलैब उपलब्ध है।

बिल्ली बनाम कुत्ते: विस्तार के साथ छवि वर्गीकरण

इस ट्यूटोरियल में, हम चर्चा करेंगे कि बिल्लियों और कुत्तों की छवियों को कैसे वर्गीकृत किया जाए। हम डेटा को लोड करने के लिए tf.keras.Sequential मॉडल का उपयोग करके एक छवि क्लासिफायरियर का विकास करेंगे, और tf.keras.Sequential का उपयोग tf.keras.Sequential ।

इस भाग में शामिल किए जाने वाले विचार:

हम एक क्लासिफायर विकसित करने और निम्नलिखित अवधारणाओं की सहज समझ विकसित करने में व्यावहारिक अनुभव प्राप्त करेंगे:

tf.keras.preprocessing.image.ImageDataGenerator वर्ग का उपयोग करके डेटा प्रवाह ( डेटा इनपुट पाइपलाइन ) के एक मॉडल का निर्माण (मॉडल के साथ बातचीत करने वाले डिस्क पर डेटा के साथ कुशलता से कैसे काम करें?)
मुकरना - यह क्या है और इसे कैसे निर्धारित किया जाए?
डेटा वृद्धि और ड्रॉपआउट पद्धति पैटर्न मान्यता कार्यों में पीछे हटने के खिलाफ लड़ाई में महत्वपूर्ण तकनीकें हैं जिन्हें हम अपने मॉडल प्रशिक्षण प्रक्रिया में लागू करेंगे।

हम मशीन सीखने के मॉडल विकसित करने में बुनियादी दृष्टिकोण का पालन करेंगे:

डेटा का अन्वेषण करें और समझें
इनपुट स्ट्रीम कॉन्फ़िगर करें
मॉडल बनाएँ
ट्रेन का मॉडल
टेस्ट मॉडल
मॉडल / दोहराने की प्रक्रिया में सुधार

शुरू करने से पहले हम ...

संपादक में कोड शुरू करने से पहले, हम अनुशंसा करते हैं कि आप रनटाइम में सभी सेटिंग्स रीसेट करें -> शीर्ष मेनू में सभी रीसेट करें । इस तरह की कार्रवाई से स्मृति की कमी के साथ समस्याओं से बचने में मदद मिलेगी, यदि आपने समानांतर में काम किया या कई संपादकों के साथ काम किया।

आयात पैकेज

आइए उन पैकेजों को आयात करके शुरू करें जिनकी आपको आवश्यकता है:

os - फाइलों और निर्देशिका संरचनाओं को पढ़ें;
numpy - numpy बाहर कुछ मैट्रिक्स परिचालनों के लिए;
matplotlib.pyplot - एक परीक्षण और सत्यापन डेटासेट से छवियों को प्लॉट करना और प्रदर्शित करना।

 from __future__ import absolute_import, division, print_function, unicode_literals import os import matplotlib.pyplot as plt import numpy as np

TensorFlow आयात TensorFlow :

 import tensorflow as tf from tensorflow.keras.preprocessing.image import ImageDataGenerator

 import logging logger = tf.get_logger() logger.setLevel(logging.ERROR)

डेटा लोड हो रहा है

हम डेटा लोड करके अपने क्लासिफायर का विकास शुरू करते हैं। डेटा सेट जो हम उपयोग करते हैं, वह कागले सेवा से सेट डॉग्स बनाम कैट्स डेटा का फ़िल्टर किया गया संस्करण है (अंत में, यह डेटा सेट Microsoft अनुसंधान द्वारा प्रदान किया गया है)।

अतीत में, CoLab और मैंने खुद TensorFlow Dataset मॉड्यूल से एक डेटासेट का उपयोग किया था, जो काम और परीक्षण के लिए बेहद सुविधाजनक है। इस CoLab में, हालांकि, हम डिस्क से डेटा पढ़ने के लिए tf.keras.preprocessing.image.ImageDataGenerator वर्ग का उपयोग करेंगे। इसलिए, पहले हमें डॉग वीएस कैट्स डेटा सेट डाउनलोड करने और इसे अनज़िप करने की आवश्यकता है।

 _URL = 'https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip' zip_dir = tf.keras.utils.get_file('cats_and_dogs_filterted.zip', origin=_URL, extract=True)

हमारे द्वारा डाउनलोड किए गए डेटासेट में निम्नलिखित संरचना है:

 cats_and_dogs_filtered |__ train |______ cats: [cat.0.jpg, cat.1.jpg, cat.2.jpg ...] |______ dogs: [dog.0.jpg, dog.1.jpg, dog.2.jpg ...] |__ validation |______ cats: [cat.2000.jpg, cat.2001.jpg, cat.2002.jpg ...] |______ dogs: [dog.2000.jpg, dog.2001.jpg, dog.2002.jpg ...]

निदेशकों की पूरी सूची प्राप्त करने के लिए, आप निम्नलिखित कमांड का उपयोग कर सकते हैं:

 zip_dir_base = os.path.dirname(zip_dir) !find $zip_dir_base -type d -print

आउटपुट (जब कोलैब से शुरू होता है):

 /root/.keras/datasets /root/.keras/datasets/cats_and_dogs_filtered /root/.keras/datasets/cats_and_dogs_filtered/train /root/.keras/datasets/cats_and_dogs_filtered/train/dogs /root/.keras/datasets/cats_and_dogs_filtered/train/cats /root/.keras/datasets/cats_and_dogs_filtered/validation /root/.keras/datasets/cats_and_dogs_filtered/validation/dogs /root/.keras/datasets/cats_and_dogs_filtered/validation/cats

अब चर के लिए प्रशिक्षण और सत्यापन के लिए डेटा सेट के साथ निर्देशिकाओं के लिए सही रास्ते असाइन करें:

 base_dir = os.path.join(os.path.dirname(zip_dir), 'cats_and_dogs_filtered') train_dir = os.path.join(base_dir, 'train') validation_dir = os.path.join(base_dir, 'validation') train_cats_dir = os.path.join(train_dir, 'cats') train_dogs_dir = os.path.join(train_dir, 'dogs') validation_cats_dir = os.path.join(validation_dir, 'cats') validation_dogs_dir = os.path.join(validation_dir, 'dogs')

डेटा और इसकी संरचना को समझना

आइए देखें कि हमारे पास परीक्षण और सत्यापन डेटा सेट (निर्देशिका) में बिल्लियों और कुत्तों की कितनी छवियां हैं।

 num_cats_tr = len(os.listdir(train_cats_dir)) num_dogs_tr = len(os.listdir(train_dogs_dir)) num_cats_val = len(os.listdir(validation_cats_dir)) num_dogs_val = len(os.listdir(validation_dogs_dir)) total_train = num_cats_tr + num_dogs_tr total_val = num_cats_val + num_dogs_val

 print('    : ', num_cats_tr) print('    : ', num_dogs_tr) print('    : ', num_cats_val) print('    : ', num_dogs_val) print('--') print('     : ', total_train) print('     : ', total_val)

निष्कर्ष:

     : 1000     : 1000     : 500     : 500 --      : 2000      : 1000

मॉडल पैरामीटर सेट करना

सुविधा के लिए, हम उन वेरिएबल्स की स्थापना करेंगे जिन्हें हमें एक अलग घोषणा में आगे की प्रक्रिया और मॉडल प्रशिक्षण के लिए आवश्यक है:

 BATCH_SIZE = 100 #          IMG_SHAPE = 150 #

डेटा एक्सटेंशन

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

tf.keras का उपयोग tf.keras हम ऐसे यादृच्छिक परिवर्तनों को लागू कर सकते हैं और ImageDataGenerator वर्ग के माध्यम से नई छवियां उत्पन्न कर सकते हैं। यह हमारे लिए पर्याप्त होगा कि हम विभिन्न परिवर्तनों के मापदंडों के रूप में गुजरें, जिन्हें हम छवियों पर लागू करना चाहते हैं, और मॉडल प्रशिक्षण के दौरान वर्ग खुद को बाकी का ध्यान रखेगा।

सबसे पहले, एक फ़ंक्शन लिखें जो यादृच्छिक परिवर्तनों के परिणामस्वरूप प्राप्त छवियों को प्रदर्शित करेगा। फिर हम मूल डेटा सेट के विस्तार की प्रक्रिया में उपयोग किए जाने वाले परिवर्तनों का अधिक विस्तार से परीक्षण करेंगे।

 def plotImages(images_arr): fig, axes = plt.subplots(1, 5, figsize=(20,20)) axes = axes.flatten() for img, ax in zip(images_arr, axes): ax.imshow(img) plt.tight_layout() plt.show()

क्षैतिज रूप से छवि को पलटें

हम एक साधारण रूपांतरण के साथ शुरू कर सकते हैं - क्षैतिज छवि flipping। आइए देखें कि यह परिवर्तन हमारी स्रोत छवियों पर कैसे लागू होगा। horizontal_flip=True ImageDataGenerator .

 image_gen = ImageDataGenerator(rescale=1./255, horizontal_flip=True) train_data_gen = image_gen.flow_from_directory(batch_size=BATCH_SIZE, directory=train_dir, shuffle=True, target_size=(IMG_SHAPE, IMG_SHAPE))

 Found 2000 images belonging to 2 classes.

. ( ) .

 augmented_images = [train_data_gen[0][0][0] for i in range(5)] plotImages(augmented_images)

(2 5 ):

. 45.

 image_gen = ImageDataGenerator(rescale=1./255, rotation_range=45) train_data_gen = image_gen.flow_from_directory(batch_size=BATCH_SIZE, directory=train_dir, shuffle=True, target_size=(IMG_SHAPE, IMG_SHAPE))

 Found 2000 images belonging to 2 classes.

— 5 . ( ) .

 augmented_images = [train_data_gen[0][0][0] for i in range(5)] plotImages(augmented_images)

(2 5):

— 50%.

 image_gen = ImageDataGenerator(rescale=1./255, zoom_range=0.5) train_data_gen = image_gen.flow_from_directory(batch_size=BATCH_SIZE, directory=train_dir, shuffle=True, target_size=(IMG_SHAPE, IMG_SHAPE))

 Found 2000 images belonging to 2 classes.

, — 5 . ( ) .

 augmented_images = [train_data_gen[0][0][0] for i in range(5)] plotImages(augmented_images)

(2 5 ):

, , , ImageDataGenerator .

— , 45 , , , .

 image_gen_train = ImageDataGenerator( rescale=1./255, rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest' ) train_data_gen = image_gen_train.flow_from_directory(batch_size=BATCH_SIZE, directory=train_dir, shuffle=True, target_size=(IMG_SHAPE, IMG_SHAPE), class_mode='binary')

 Found 2000 images belonging to 2 classes.

, .

 augmented_images = [train_data_gen[0][0][0] for i in range(5)] plotImages(augmented_images)

(2 5):

, , , . , , .

 image_gen_val = ImageDataGenerator(rescale=1./255) val_data_gen = image_gen_val.flow_from_directory(batch_size=BATCH_SIZE, directory=validation_dir, target_size=(IMG_SHAPE, IMG_SHAPE), class_mode='binary')

4 .

0.5. , 50% 0. .

512 relu . — — softmax .

 model = tf.keras.models.Sequential([ tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(IMG_SHAPE, IMG_SHAPE, 3)), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(128, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(128, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Dropout(0.5), tf.keras.layers.Flatten(), tf.keras.layers.Dense(512, activation='relu'), tf.keras.layers.Dense(2, activation='softmax') ])

adam . sparse_categorical_crossentropy . , accuracy metrics :

 model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

summary :

 model.summary()

 Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 148, 148, 32) 896 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 74, 74, 32) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 72, 72, 64) 18496 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 36, 36, 64) 0 _________________________________________________________________ conv2d_2 (Conv2D) (None, 34, 34, 128) 73856 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 17, 17, 128) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 15, 15, 128) 147584 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 7, 7, 128) 0 _________________________________________________________________ dropout (Dropout) (None, 7, 7, 128) 0 _________________________________________________________________ flatten (Flatten) (None, 6272) 0 _________________________________________________________________ dense (Dense) (None, 512) 3211776 _________________________________________________________________ dense_1 (Dense) (None, 2) 1026 ================================================================= Total params: 3,453,634 Trainable params: 3,453,634 Non-trainable params: 0 _________________________________________________________________

( ImageDataGenerator ) fit_generator fit :

 EPOCHS = 100 history = model.fit_generator( train_data_gen, steps_per_epoch=int(np.ceil(total_train / float(BATCH_SIZE))), epochs=EPOCHS, validation_data=val_data_gen, validation_steps=int(np.ceil(total_val / float(BATCH_SIZE))) )

 acc = history.history['acc'] val_acc = history.history['val_acc'] loss = history.history['loss'] val_loss = history.history['val_loss'] epochs_range = range(EPOCHS) plt.figure(figsize=(8,8)) plt.subplot(1, 2, 1) plt.plot(epochs_range, acc, label='  ') plt.plot(epochs_range, val_acc, label='  ') plt.legend(loc='lower right') plt.title('     ') plt.subplot(1, 2, 2) plt.plot(epochs_range, loss, label='  ') plt.plot(epochs_range, val_loss, label='  ') plt.legend(loc='upper right') plt.title('     ') plt.savefig('./foo.png') plt.show()

, :

: ( ).
(.. augmentation) : .
/ (.. dropout) : ( , ).

, . .

:

CoLab .
CoLab .

. CoLab . CoLab . CoLab , .

CoLab. CoLab , , .

# tf.keras

CoLab . tf.keras.Sequential , ImageDataGenerator .

. os , numpy python- numpy- , , matplotlib.pyplot .

 from __future__ import absolute_import, division, print_function, unicode_literals import os import numpy as np import glob import shutil import matplotlib.pyplot as plt

TODO: TensorFlow Keras-

TensorFlow tf Keras- , . , ImageDataGenerator - Keras .

— . .

 _URL = "https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz" zip_file = tf.keras.utils.get_file(origin=_URL, fname="flower_photos.tgz", extract=True) base_dir = os.path.join(os.path.dirname(zip_file), 'flower_photos')

, , 5 :

 classes = ['', '', '', '', '']

, , :

 flower_photos |__ diasy |__ dandelion |__ roses |__ sunflowers |__ tulips

. . , .

2 train val 5 - ( ). , 80% , 20% . :

 flower_photos |__ diasy |__ dandelion |__ roses |__ sunflowers |__ tulips |__ train |______ daisy: [1.jpg, 2.jpg, 3.jpg ....] |______ dandelion: [1.jpg, 2.jpg, 3.jpg ....] |______ roses: [1.jpg, 2.jpg, 3.jpg ....] |______ sunflowers: [1.jpg, 2.jpg, 3.jpg ....] |______ tulips: [1.jpg, 2.jpg, 3.jpg ....] |__ val |______ daisy: [507.jpg, 508.jpg, 509.jpg ....] |______ dandelion: [719.jpg, 720.jpg, 721.jpg ....] |______ roses: [514.jpg, 515.jpg, 516.jpg ....] |______ sunflowers: [560.jpg, 561.jpg, 562.jpg .....] |______ tulips: [640.jpg, 641.jpg, 642.jpg ....]

, , . .

 for cl in classes: img_path = os.path.join(base_dir, cl) images = glob.glob(img_path + '/*.jpg') print("{}: {} ".format(cl, len(images))) train, val = images[:round(len(images)*0.8)], images[round(len(images)*0.8):] for t in train: if not os.path.exists(os.path.join(base_dir, 'train', cl)): os.makedirs(os.path.join(base_dir, 'train', cl)) shutil.move(t, os.path.join(base_dir, 'train', cl)) for v in val: if not os.path.exists(os.path.join(base_dir, 'val', cl)): os.makedirs(os.path.join(base_dir, 'val', cl)) shutil.move(v, os.path.join(base_dir, 'val', cl))

 train_dir = os.path.join(base_dir, 'train') val_dir = os.path.join(base_dir, 'val')

, , , . — (.. augmentation) . . , , — , . .

tf.keras , — ImageDataGenerator . .

. — () batch_size , IMG_SHAPE .

TODO:

100 batch_size 150 IMG_SHAPE :

 batch_size = IMG_SHAPE =

TODO:

ImageDataGenerator , , . .flow_from_directory . , , , .

 image_gen = train_data_gen =

5 :

 def plotImages(images_arr): fig, axes = plt.subplots(1, 5, figsize=(20,20)) axes = axes.flatten() for img, ax in zip(images_arr, axes): ax.imshow(img) plt.tight_layout() plt.show() augmented_images = [train_data_gen[0][0][0] for i in range(5)] plotImages(augmented_images)

TODO:

, ImageDataGenerator 45 . .flow_from_directory . , , , .

 image_gen = train_data_gen =

5 :

 augmented_images = [train_data_gen[0][0][0] for i in range(5)] plotImages(augmented_images)

TODO:

, ImageDataGenerator 50%. .flow_from_directory . , , , .

 image_gen = train_data_gen =

5 :

 augmented_images = [train_data_gen[0][0][0] for i in range(5)] plotImages(augmented_images)

TODO:

, ImageDataGenerator :

45
50%
0.15
0.15

flow_from_directory . , , , .

 image_gen_train = train_data_gen =

5 :

 augmented_images = [train_data_gen[0][0][0] for i in range(5)] plotImages(augmented_images)

TODO:

. , , ImageDataGenerator , . flow_from_directory . , , . .

 image_gen_val = val_data_gen =

TODO:

, 3 — . 16 , — 32 , — 64 . 33. 22.

Flatten , 512 . 5 , softmax . relu . , , 20%.

 model =

TODO:

, adam sparse_categorical_crossentropy . , compile(...) .

TODO:

, fit_generator fit , . fit_generator ImageDataGenerator . 80 , fit_generator -.

 epochs = history =

TODO: /

, :

 acc = val_acc = loss = val_loss = epochs_range =

TODO:

( + ) 512 . . . , , .. , ImageDataGenerator — . , .

RGB- :

: , ( );
: 3D-;
RGB- : 3 : , ;
: (). , (). — .
: . , .
: . , .

: , .
: .
() : .

. , . .

… call-to-action — , share :)
YouTube
तार
VKontakte

दृढ़ तंत्रिका नेटवर्क में विसर्जन। भाग 5/10 - 18

सामग्री

सॉफ्टमैक्स और सिगमॉइड

मान्यता

छवि विस्तार (वृद्धि)

अपवाद (ड्रॉपआउट)

CoLab: कुत्तों और बिल्लियों। दुहराव

बिल्ली बनाम कुत्ते: विस्तार के साथ छवि वर्गीकरण

इस भाग में शामिल किए जाने वाले विचार:

हम मशीन सीखने के मॉडल विकसित करने में बुनियादी दृष्टिकोण का पालन करेंगे:

आयात पैकेज

डेटा लोड हो रहा है

डेटा और इसकी संरचना को समझना

मॉडल पैरामीटर सेट करना

डेटा एक्सटेंशन

क्षैतिज रूप से छवि को पलटें

:

TODO: TensorFlow Keras-

TODO:

TODO:

TODO:

TODO:

TODO:

TODO:

TODO:

TODO:

TODO:

TODO: /

TODO:

More articles: