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

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

सामग्री

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

सेबस्टियन ट्रन के साथ साक्षात्कार

- तो, आज हम फिर से यहां हैं, सेबेस्टियन के साथ और हम रिट्रीटिंग के बारे में बात करेंगे। यह विषय हमारे लिए बहुत दिलचस्प है, विशेष रूप से TensorFlow के साथ काम करने पर वर्तमान पाठ्यक्रम के व्यावहारिक भागों में।
- सेबस्टियन, क्या आपने कभी ओवरफिटिंग - ओवर, फिट का सामना किया है? यदि आप कहते हैं कि आपने सामना नहीं किया है, तो मैं निश्चित रूप से कहूंगा कि मैं आप पर विश्वास नहीं कर सकता!
- तो, रिट्रेनिंग का कारण तथाकथित पूर्वाग्रह-विचरण व्यापार-बंद (पूर्वाग्रह पैरामीटर के मूल्यों और उनके प्रसार के बीच एक समझौता) है। एक तंत्रिका नेटवर्क जिसमें वजन की एक छोटी संख्या पर्याप्त उदाहरणों को सीखने में सक्षम नहीं है, मशीन सीखने में इसी तरह की स्थिति को विरूपण कहा जाता है।
- हां।
- इतने सारे मापदंडों के साथ एक तंत्रिका नेटवर्क मनमाने ढंग से एक समाधान चुन सकता है जिसे आप पसंद नहीं करते हैं, बस इन मापदंडों की इतनी बड़ी संख्या के कारण। तंत्रिका नेटवर्क समाधान चुनने का परिणाम स्रोत डेटा की परिवर्तनशीलता पर निर्भर करता है। इस प्रकार, एक सरल नियम तैयार किया जा सकता है: डेटा के आकार (मात्रा) के बारे में नेटवर्क में जितने अधिक पैरामीटर हैं, उतना ही यह सही एक के बजाय एक यादृच्छिक समाधान प्राप्त करने की संभावना है। उदाहरण के लिए, आप अपने आप से पूछते हैं, "इस कमरे में कौन आदमी है और कौन महिला है?" एक जटिल तंत्रिका नेटवर्क आपको बता सकता है कि, उदाहरण के लिए, जिनके नाम टी से शुरू होते हैं वे सभी पुरुष होते हैं और कभी भी पीछे नहीं हटते हैं। दो उपाय हैं। इनमें से पहला एक होल्डआउट डेटा सेट (मॉडल की सटीकता को मान्य करने के लिए प्रशिक्षण सेट से थोड़ी मात्रा में) का उपयोग करता है। आप डेटा ले सकते हैं, इसे दो भागों में विभाजित कर सकते हैं - प्रशिक्षण के लिए 90%, और तथाकथित क्रॉस-सत्यापन के परीक्षण और संचालन के लिए 10%, जहां आप उस डेटा की मॉडल की सटीकता की जांच करते हैं जिसे तंत्रिका नेटवर्क ने नहीं देखा था - जैसे ही त्रुटि मान शुरू होता है एक निश्चित प्रशिक्षण चक्र के बाद बढ़ने के लिए - यह सीखने को रोकने का समय है। दूसरा उपाय तंत्रिका नेटवर्क में प्रतिबंध लागू करना है। उदाहरण के लिए, विस्थापन और भार के मापदंडों के मूल्यों को सीमित करने के लिए, उन्हें करीब और शून्य के करीब लाना। वजन जितना अधिक सीमित होगा, मॉडल उतना ही कम होगा।
- मैं सही ढंग से समझता हूं कि हमारे पास प्रशिक्षण और परीक्षण और सत्यापन दोनों के लिए डेटा सेट हो सकते हैं, है ना?
- ठीक है। यदि आपके पास सत्यापन के लिए कोई डेटासेट है, तो आपके पास एक ऐसा डेटासेट होना चाहिए, जिसे आपने अपने तंत्रिका नेटवर्क को कभी नहीं छुआ या दिखाया गया हो। यदि आपने मॉडल को एक निश्चित डेटा सेट को कई बार दिखाया है, तो, निश्चित रूप से, पुनर्प्रशिक्षण प्रक्रिया शुरू हो जाएगी, जो हमारे लिए बहुत बुरा है।
- शायद आप सबसे दिलचस्प मामलों को याद करेंगे जब आपका मॉडल वापस लिया गया था?
- आह, हाँ ... मेरे शुरुआती युवाओं में ऐसी घटना हुई थी जब मैं शतरंज खेलने के लिए एक तंत्रिका नेटवर्क विकसित कर रहा था। यह 1993 में था। क्या दिलचस्प था कि शतरंज के आंकड़ों से, जिस पर तंत्रिका नेटवर्क को प्रशिक्षित किया गया था, नेटवर्क ने जल्दी से निर्धारित किया कि यदि कोई विशेषज्ञ रानी को शतरंज के केंद्र में ले जाता है, तो जीतने का 60% मौका है। वह जो करना शुरू कर रही थी वह एक मोहरे के साथ "मार्ग" को खोलने और रानी को शतरंज के केंद्र में ले जाने के लिए था। यह किसी भी शतरंज के खिलाड़ी के लिए एक मूर्खतापूर्ण निर्णय था, जिसने स्पष्ट रूप से मॉडल की फिर से जाँच करने की गवाही दी।
- बढ़िया! इसलिए, हमने अपने मॉडल को बेहतर बनाने के बारे में कई तकनीकों पर चर्चा की है। आपको क्या लगता है कि गहन सीखने का सबसे कम पक्ष है?
- आपके 90% काम को कम करके आंका गया है, क्योंकि आपके 90% काम में डेटा की सफाई शामिल होगी।
- यहाँ मैं आपसे पूरी तरह सहमत हूँ!
- जैसा कि अभ्यास से पता चलता है, किसी भी डेटा सेट में किसी प्रकार का कचरा होता है। डेटा को सही तरह से लाना बहुत मुश्किल है, इसे सुसंगत बनाने के लिए, यह बहुत समय लेने वाली प्रक्रिया है।
- हां, भले ही आप छवियों या वीडियो के रूप में ऐसे डेटा सेट के साथ काम करते हैं, जहां, ऐसा प्रतीत होता है, सभी जानकारी पहले से ही है, अंदर, अभी भी छवियों को पूर्व-संसाधित करने की आवश्यकता है।
- एकमात्र लोग जिनके लिए डेटा आदर्श हैं वे प्रोफेसर हैं, क्योंकि उनके पास PowerPoint में एक प्रस्तुति में दिखावा करने का अवसर है कि सब कुछ वैसा ही है जैसा कि होना चाहिए और सब कुछ सही है! वास्तव में, आपका 90% समय डेटा क्लींजिंग द्वारा कब्जा कर लिया जाएगा।
- बढ़िया। तो, चलिए पता लगाने के बारे में अधिक जानकारी प्राप्त करें और तकनीकें जो हमें अपने गहन शिक्षण मॉडल को बेहतर बनाने की अनुमति देंगी।

परिचय

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

बिल्ली और कुत्ते डेटासैट

उस क्षण तक, हमने केवल फैशन छवियों और आकारों के साथ 28x28 फैशन MNIST डेटासेट से काम किया।

वास्तविक अनुप्रयोगों में, हमें विभिन्न आकारों की छवियों का सामना करने के लिए मजबूर किया जाता है, उदाहरण के लिए, जो नीचे दिखाए गए हैं:

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

अपनी योजनाओं को लागू करने के लिए, हम Microsoft Asirra डेटासेट से बिल्लियों और कुत्तों की छवियों का उपयोग करेंगे। इस डेटासेट में प्रत्येक छवि को क्रमशः छवि में एक कुत्ता या बिल्ली होने पर 1 या 0 लेबल किया जाता है।

इस तथ्य के बावजूद कि Microsoft Asirra डेटासेट में बिल्लियों और कुत्तों की 3 मिलियन से अधिक टैग की गई छवियां हैं, केवल 25,000 सार्वजनिक रूप से उपलब्ध हैं। इन 25,000 छवियों पर हमारे दृढ़ तंत्रिका नेटवर्क को प्रशिक्षित करने में बहुत समय लगेगा। यही कारण है कि हम उपलब्ध 25,000 से हमारे दृढ़ तंत्रिका नेटवर्क को प्रशिक्षित करने के लिए कम संख्या में छवियों का उपयोग करेंगे।

प्रशिक्षण छवियों के हमारे सबसेट में मॉडल सत्यापन के लिए 2,000 पीसी और 1,000 पीसी छवियां शामिल हैं। प्रशिक्षण डेटासेट में, 1,000 चित्रों में बिल्लियाँ हैं और अन्य 1,000 चित्रों में कुत्ते हैं। हम पाठ के इस भाग में थोड़ी देर बाद सत्यापन के लिए निर्धारित डेटा के बारे में बात करेंगे।

इस डेटा सेट के साथ काम करते हुए, हम दो मुख्य कठिनाइयों का सामना करेंगे - विभिन्न आकारों की छवियों के साथ काम करना और रंग छवियों के साथ काम करना।

आइए विभिन्न आकारों की छवियों के साथ काम करने का तरीका तलाशना शुरू करें।

विभिन्न आकारों की छवियाँ

विभिन्न आकारों की छवियों के प्रसंस्करण की समस्या को हल करने के लिए हमारा पहला परीक्षण होगा। ऐसा इसलिए है क्योंकि इनपुट पर एक तंत्रिका नेटवर्क को एक निश्चित आकार के डेटा की आवश्यकता होती है।

एक उदाहरण के रूप में, आप एक परत परत बनाते समय input_shape पैरामीटर का उपयोग करके हमारे पिछले भागों से याद कर सकते हैं:

कपड़ों के तत्व की छवि को तंत्रिका नेटवर्क में संचारित करने से पहले, हमने इसे एक निश्चित आकार के 1D सरणी में परिवर्तित कर दिया - 28x28 = 784 तत्व (पिक्सेल)। चूंकि फैशन एमएनआईएसटी डेटासेट में छवियां समान आकार की थीं, जिसके परिणामस्वरूप एक आयामी आयाम समान आकार था और इसमें 784 तत्व शामिल थे।

हालांकि, विभिन्न आकारों (ऊंचाई और चौड़ाई) की छवियों के साथ काम करना और उन्हें एक-आयामी सरणियों में बदलना, हमें विभिन्न आकारों के सरणियां मिलती हैं।

चूंकि इनपुट पर तंत्रिका नेटवर्क को समान आकार के डेटा की आवश्यकता होती है, इसलिए यह केवल पिक्सेल मूल्यों के एक आयामी सरणी में रूपांतरण के साथ दूर होने के लिए पर्याप्त नहीं है।

छवि वर्गीकरण की समस्याओं को हल करते हुए, हम हमेशा इनपुट डेटा को एकीकृत करने के लिए विकल्पों में से एक का सहारा लेते हैं - छवियों के आकार को सामान्य मूल्यों (आकार बदलने) के लिए कम करना।

इस ट्यूटोरियल में, हम सभी छवियों को आकार में 150 पिक्सलों के आकार और चौड़ाई में 150 पिक्सल्स का आकार देने का सहारा लेंगे। छवियों को एक एकल आकार में परिवर्तित करते हुए, हम इस बात की गारंटी देते हैं कि सही आकार की छवि तंत्रिका नेटवर्क के इनपुट पर आ जाएगी और जब एक flatten परत में स्थानांतरित की जाती है, तो हमें समान आकार का एक आयामी आयाम मिलता है।

 tf.keras.layers.Flatten(input_shape(150,150,1))

परिणामस्वरूप, हमें 150x150 = 22,500 मानों (पिक्सेल) से युक्त एक आयामी आयाम मिला।

अगली समस्या जो हम सामना करेंगे वह रंग - रंग की छवियों की समस्या होगी। हम उनके बारे में अगले भाग में बात करेंगे।

रंग छवियों। भाग 1

यह समझने और समझने के लिए कि रंग चित्र के साथ कैसे दृढ़ तंत्रिका नेटवर्क काम करते हैं, हमें इस बात पर ध्यान देना चाहिए कि एसएनए सामान्य रूप से कैसे काम करता है। आइए हम जो पहले से जानते हैं उसे ताज़ा करें।

ऊपर एक उदाहरण एक ग्रेस्केल छवि है और कंप्यूटर इसे पिक्सेल मूल्यों के दो आयामी सरणी के रूप में कैसे व्याख्या करता है।

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

3 डी सरणी की ऊंचाई और चौड़ाई छवि की ऊंचाई और चौड़ाई से निर्धारित की जाएगी, और गहराई (गहराई) छवि के रंग चैनलों की संख्या निर्धारित करती है।

अधिकांश रंग छवियों को तीन रंग चैनलों द्वारा दर्शाया जा सकता है - लाल (लाल), हरा (हरा) और नीला (नीला)।

ऐसी छवियां जो लाल, हरे और नीले चैनल से युक्त होती हैं, उन्हें RGB चित्र कहा जाता है। इन तीन चैनलों के संयोजन से एक रंग की छवि बनती है। RGB छवियों में, प्रत्येक चैनल को पिक्सेल के एक अलग दो-आयामी सरणी द्वारा दर्शाया जाता है।

चूंकि हमारे पास चैनलों की संख्या तीन है, इसलिए परिणामस्वरूप हमारे पास तीन दो आयामी सरणियाँ होंगी। इस प्रकार, 3 रंगीन चैनलों से युक्त एक रंगीन छवि में निम्नलिखित प्रतिनिधित्व होगा:

रंग छवियों। भाग २

इसलिए, चूंकि हमारी छवि अब 3 रंगों से मिलकर बनेगी, जिसका अर्थ है कि यह पिक्सेल मूल्यों का त्रि-आयामी सरणी होगा, तो हमारे कोड को तदनुसार बदलना होगा।

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

 model = Sequential() model.add(Conv2D(32, 3, padding='same', activation='relu', input_shape=(28,28,1)))

टपल के पहले दो पैरामीटर (28,28,1) छवि की ऊंचाई और चौड़ाई के मान हैं। फैशन MNIST डेटासेट में चित्र 28x28 पिक्सेल आकार के थे। टपल में अंतिम पैरामीटर (28,28,1) रंग चैनलों की संख्या को दर्शाता है। फ़ैशन MNIST डेटासेट में, चित्र केवल ग्रे - 1 रंग चैनल के शेड में थे।

अब जब कार्य थोड़ा और अधिक जटिल हो गया है, और बिल्लियों और कुत्तों की हमारी छवियां अलग-अलग आकार की हो गई हैं (लेकिन एक एकल - 150x150 पिक्सल में परिवर्तित हो गई हैं) और 3 रंग चैनल शामिल हैं, तो मूल्यों का ट्यूप भी अलग होना चाहिए:

 model = Sequential() model.add(Conv2D(16, 3, padding='same', activation='relu', input_shape=(150,150,3)))

अगले भाग में, हम देखेंगे कि चित्र में तीन रंगीन चैनलों की उपस्थिति में कैसे गणना की जाती है।

रंग छवियों पर बातचीत ऑपरेशन

पिछले पाठों में, हमने सीखा कि ग्रेस्केल छवियों पर एक कनवल्शन ऑपरेशन कैसे किया जाता है। लेकिन रंग छवियों पर एक दृढ़ संकल्प ऑपरेशन कैसे करें? आइए दोहराते हुए शुरू करें कि ग्रेस्केल छवियों पर कनवल्शन ऑपरेशन कैसे किया जाता है।

यह सब एक निश्चित आकार के फ़िल्टर (कोर) से शुरू होता है।

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

यह भी याद रखने योग्य है कि दृढ़ संकल्प ऑपरेशन के दौरान, ताकि छवि की सीमाओं पर जानकारी न खोएं, हम संरेखण लागू कर सकते हैं और शून्य के साथ छवि के किनारों को पैड कर सकते हैं:

अब हम यह पता लगाते हैं कि हम रंग चित्रों पर कनवल्शन ऑपरेशन कैसे कर सकते हैं।

जिस तरह एक छवि को धूसर रंग में परिवर्तित करते हुए, हम एक निश्चित आकार के फ़िल्टर (कोर) के आकार को चुनकर शुरू करते हैं।

अंतर केवल इतना होगा कि अब फ़िल्टर स्वयं त्रि-आयामी होगा, और गहराई पैरामीटर का मान छवि में रंग चैनलों की संख्या के मान के बराबर होगा - 3 (हमारे मामले में, RGB)। रंग चैनल के प्रत्येक "लेयर" के लिए, हम चयनित आकार के एक फिल्टर के साथ कनवल्शन ऑपरेशन भी लागू करेंगे। आइए देखें कि यह एक उदाहरण कैसे होगा।

कल्पना करें कि हमारे पास एक आरजीबी छवि है और हम अगले 3 डी फिल्टर के साथ कनवल्शन ऑपरेशन लागू करना चाहते हैं। यह इस तथ्य पर ध्यान देने योग्य है कि हमारे फ़िल्टर में 3 द्वि-आयामी फ़िल्टर होते हैं। सरलता के लिए, आइए कल्पना करें कि हमारी RGB छवि 5x5 पिक्सेल आकार की है।

यह भी याद रखें कि प्रत्येक रंग चैनल पिक्सेल रंग मूल्यों का एक दो-आयामी सरणी है।

रंगों के साथ-साथ रंगों की छवियों के साथ-साथ रंगीन चित्रों पर दीक्षांत समारोह के संचालन के साथ - हम सीमाओं पर जानकारी के नुकसान को रोकने के लिए शून्य पर किनारों के साथ संरेखण और छवि को पूरक करेंगे।

अब हम कनवल्शन ऑपरेशन के लिए तैयार हैं!

रंगीन चित्रों के लिए कनवल्शन तंत्र उस प्रक्रिया के समान होगा जो हमने ग्रेस्केल छवियों के साथ किया था। ग्रेस्केल और रंगीन चित्रों पर किए गए ऑपरेशनों के बीच एकमात्र अंतर यह है कि प्रत्येक रंगीन चैनल के लिए कनवल्शन ऑपरेशन को अब 3 बार किया जाना चाहिए।

फिर, जब हमने प्रत्येक रंगीन चैनल पर कनवल्शनशन ऑपरेशन किया है, तीन प्राप्त मानों को जोड़ें और उनमें से 1 को जोड़ें (इस तरह के संचालन करते समय उपयोग किया जाने वाला मानक मान)। परिणामी नया मान नई छवि में उसी स्थिति में तय किया गया है, जिस स्थिति में वर्तमान परिवर्तित पिक्सेल था।

हम अपनी मूल छवि में और प्रत्येक रंग चैनल के लिए प्रत्येक पिक्सेल के लिए एक समान रूपांतरण ऑपरेशन (एक कनवल्शन ऑपरेशन) करते हैं।

इस विशेष उदाहरण में, परिणामी छवि हमारी मूल RGB छवि के समान ऊँचाई और चौड़ाई में समान आकार की है।

जैसा कि आप देख सकते हैं, एक एकल 3D फ़िल्टर परिणामों के साथ कनवल्शन ऑपरेशन को लागू करने से एकल आउटपुट मान प्राप्त होता है।

हालांकि, जब संवेदी तंत्रिका नेटवर्क के साथ काम करते हैं, तो एक से अधिक 3 डी फिल्टर का उपयोग करना आम बात है। यदि हम एक से अधिक 3 डी फ़िल्टर का उपयोग करते हैं, तो परिणाम कई आउटपुट मान होंगे - प्रत्येक मान एक फ़िल्टर का परिणाम है।

ऊपर हमारे उदाहरण में, चूंकि हम 3 फिल्टर का उपयोग करते हैं, परिणामस्वरूप 3 डी प्रतिनिधित्व में 3 की गहराई होगी - प्रत्येक परत अपने सभी रंग चैनलों के साथ छवि के ऊपर एक फिल्टर के रूपांतरण के आउटपुट मूल्य के अनुरूप होगी।

यदि, उदाहरण के लिए, 3 फ़िल्टर के बजाय, हमने 16 का उपयोग करने का निर्णय लिया, तो आउटपुट 3 डी प्रतिनिधित्व में 16 गहराई परतें होंगी।

कोड में, हम filters पैरामीटर के लिए उचित मान पास करके बनाए गए फ़िल्टर की संख्या को नियंत्रित कर सकते हैं:

 tf.keras.layers.Conv2D(filters, kernel_size, ...)

हम kernel_size पैरामीटर के माध्यम से फ़िल्टर का आकार भी निर्दिष्ट कर सकते हैं। उदाहरण के लिए, आकार 3x3 के 3 फिल्टर बनाने के लिए, जैसा कि ऊपर हमारे उदाहरण में हुआ था, हम कोड निम्नानुसार लिख सकते हैं:

 tf.keras.layers.Conv2D(3, (3,3), ...)

याद रखें कि सजा हुआ तंत्रिका नेटवर्क के प्रशिक्षण के दौरान, 3 डी फिल्टर में मूल्यों को नुकसान फ़ंक्शन के मूल्य को कम करने के लिए अपडेट किया जाएगा।

अब जब हम जानते हैं कि रंग चित्रों पर कनवल्शन ऑपरेशन कैसे किया जाता है, तो यह पता लगाने का समय है कि अधिकतम मूल्य (एक ही अधिकतम-पूलिंग) द्वारा अधिकतम परिणाम के लिए सबसम्पलिंग ऑपरेशन कैसे लागू किया जाए।

रंग छवियों में अधिकतम मूल्य से सबसम्पलिंग का संचालन

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

सादगी के लिए, आइए कल्पना करें कि हमारा आउटपुट दृश्य इस तरह दिखता है:

पहले की तरह, हम अधिकतम मूल्य पर सबसम्पलिंग ऑपरेशन करने के लिए 2x2 कर्नेल और चरण 2 का उपयोग करेंगे। अधिकतम मान द्वारा सबसैंपलिंग का संचालन प्रत्येक आउटपुट प्रतिनिधित्व के ऊपरी बाएं कोने में 2x2 कर्नेल के "इंस्टॉलेशन" से शुरू होता है (कन्वेक्शन ऑपरेशन को लागू करने के बाद प्राप्त किया गया प्रतिनिधित्व)।

अब हम अधिकतम मूल्य पर सबसम्पलिंग ऑपरेशन शुरू कर सकते हैं। उदाहरण के लिए, हमारे पहले आउटपुट प्रतिनिधित्व में, निम्न मान 2x2 कर्नेल में गिर गए - 1, 9, 5, 4. 4. चूंकि इस कर्नेल में अधिकतम मूल्य 9 है, यह वह है जो नए आउटपुट प्रतिनिधित्व को भेजा जाता है। प्रत्येक इनपुट प्रतिनिधित्व के लिए एक समान ऑपरेशन दोहराया जाता है।

परिणामस्वरूप, हमें निम्नलिखित परिणाम प्राप्त करना चाहिए:

अधिकतम मान द्वारा सबसम्पलिंग ऑपरेशन करने के बाद, परिणाम 3 द्वि-आयामी सरणियों है, जिनमें से प्रत्येक मूल इनपुट प्रतिनिधित्व से 2 गुना छोटा है।

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

इसलिए, यह संपूर्ण सिद्धांत है जिसे हमें आगे काम करने की आवश्यकता होगी। अब देखते हैं कि यह कोड में कैसे काम करता है!

कोलैब: बिल्लियों और कुत्तों

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

इस ट्यूटोरियल में, हम चर्चा करेंगे कि बिल्लियों और कुत्तों की छवियों को कैसे वर्गीकृत किया जाए। हम डेटा को लोड करने के लिए 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 #  150x150

डेटा की तैयारी

इससे पहले कि छवियों को हमारे नेटवर्क के लिए इनपुट के रूप में उपयोग किया जा सकता है, उन्हें फ्लोटिंग पॉइंट वैल्यू के साथ टेंसरों में बदलना चाहिए। ऐसा करने के लिए उठाए जाने वाले कदमों की सूची:

डिस्क से चित्र पढ़ें
छवि सामग्री को डीकोड करें और आरजीबी प्रोफाइल को ध्यान में रखते हुए वांछित प्रारूप में परिवर्तित करें
अस्थायी बिंदु मानों के साथ दहाई में बदलें
0 से 255 के अंतराल से 0 से 1 के अंतराल से टेंसर मूल्यों को सामान्य करने के लिए, चूंकि तंत्रिका नेटवर्क छोटे इनपुट मूल्यों के साथ बेहतर काम करते हैं।

सौभाग्य से, इन सभी ऑपरेशनों का उपयोग tf.keras.preprocessing.image.ImageDataGenerator class का उपयोग करके किया जा सकता है।

हम कोड की कई लाइनों का उपयोग करके यह सब कर सकते हैं:

 train_image_generator = ImageDataGenerator(rescale=1./255) validation_image_generator = ImageDataGenerator(rescale=1./255)

जब हमने परीक्षण और सत्यापन डेटा के सेट के लिए जनरेटर निर्धारित किया है, तो flow_from_directory विधि डिस्क से छवियों को लोड करेगी , डेटा को सामान्य करेगी और कोड की सिर्फ एक पंक्ति के साथ छवियों का आकार बदल सकती है:

 train_data_gen = train_image_generator.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.

सत्यापन डेटा जनरेटर:

 val_data_gen = validation_image_generator.flow_from_directory(batch_size=BATCH_SIZE, directory=validation_dir, shuffle=False, target_size=(IMG_SHAPE,IMG_SHAPE), class_mode='binary')

निष्कर्ष:

 Found 1000 images belonging to 2 classes.

प्रशिक्षण सेट से छवियों की कल्पना करें।

हम matplotlib का उपयोग कर एक प्रशिक्षण डाटासेट से छवियों की कल्पना कर सकते हैं:

 sample_training_images, _ = next(train_data_gen)

next फ़ंक्शन डेटा सेट से छवियों का एक ब्लॉक लौटाता है। एक ब्लॉक (कई चित्र, कई लेबल) का एक टपल है। फिलहाल, हम लेबल को छोड़ देंगे, क्योंकि हमें उनकी आवश्यकता नहीं है - हम खुद छवियों में रुचि रखते हैं।

 #        15 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()

 plotImages(sample_training_images[:5]) #   0-4

उदाहरण आउटपुट (सभी 5 के बजाय 2 चित्र):

मॉडल निर्माण

हम मॉडल का वर्णन करते हैं

मॉडल में 4 कनवल्शन ब्लॉक होते हैं, जिनमें से प्रत्येक के बाद एक सबमिशन परत के साथ एक ब्लॉक होता है। अगला, हमारे पास 512 न्यूरॉन्स और एक relu सक्रियण relu साथ पूरी तरह से जुड़ा हुआ परत relu । मॉडल दो वर्गों - कुत्तों और बिल्लियों - softmax का उपयोग करके एक संभाव्यता वितरण 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.Flatten(), tf.keras.layers.Dense(512, activation='relu'), tf.keras.layers.Dense(2, activation='softmax') ])

मॉडल संकलन

पहले की तरह, हम adam अनुकूलक का उपयोग करेंगे। हम एक हानि फ़ंक्शन के रूप में sparse_categorical_crossentropy उपयोग करते हैं। हम प्रत्येक प्रशिक्षण पुनरावृत्ति पर मॉडल की सटीकता की निगरानी करना चाहते हैं, इसलिए हम metrics पैरामीटर को accuracy का मूल्य देते हैं:

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

मॉडल दृश्य

आइए सारांश विधि का उपयोग करके स्तरों द्वारा हमारे मॉडल की संरचना पर एक नज़र डालें:

 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 _________________________________________________________________ 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()

निष्कर्ष:

, 70% ( ).

. , .

… .

… call-to-action — , share :)

यूट्यूब
तार
VKontakte

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

सामग्री

सेबस्टियन ट्रन के साथ साक्षात्कार

परिचय

बिल्ली और कुत्ते डेटासैट

विभिन्न आकारों की छवियाँ

रंग छवियों। भाग 1

रंग छवियों। भाग २

रंग छवियों पर बातचीत ऑपरेशन

रंग छवियों में अधिकतम मूल्य से सबसम्पलिंग का संचालन

कोलैब: बिल्लियों और कुत्तों

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

आयात पैकेज

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

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

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

डेटा की तैयारी

प्रशिक्षण सेट से छवियों की कल्पना करें।

मॉडल निर्माण

हम मॉडल का वर्णन करते हैं

मॉडल संकलन

मॉडल दृश्य

More articles: