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

सामग्री

सेबस्टियन ट्रन के साथ साक्षात्कार
परिचय
स्थानांतरण मॉडल सीखना
MobileNet
कोलैब: स्थानांतरण प्रशिक्षण के साथ बिल्लियों बनाम कुत्ते
दृढ़ तंत्रिका नेटवर्क में गोताखोरी
व्यावहारिक भाग: प्रशिक्षण के हस्तांतरण के साथ रंगों का निर्धारण
परिणाम

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

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

परिचय

- नमस्कार और वापस स्वागत है!
- पिछली बार हमने छवि में बिल्लियों और कुत्तों को वर्गीकृत करने के लिए एक सजातीय तंत्रिका नेटवर्क को प्रशिक्षित किया था। हमारा पहला तंत्रिका नेटवर्क पीछे हट गया था, इसलिए इसका परिणाम इतना अधिक नहीं था - लगभग 70% सटीकता। उसके बाद, हमने डेटा एक्सटेंशन और ड्रॉपआउट (न्यूरॉन्स के मनमाने ढंग से वियोग) को लागू किया, जिसने हमें अनुमानों की सटीकता को 80% तक बढ़ाने की अनुमति दी।
- इस तथ्य के बावजूद कि 80% एक उत्कृष्ट संकेतक की तरह लग सकता है, 20% त्रुटि अभी भी बहुत बड़ी है। है ना? वर्गीकरण की सटीकता बढ़ाने के लिए हम क्या कर सकते हैं? इस पाठ में, हम ज्ञान हस्तांतरण तकनीक (ज्ञान मॉडल के हस्तांतरण) का उपयोग करेंगे, जो हमें विशेषज्ञों द्वारा विकसित मॉडल का उपयोग करने और विशाल डेटा सरणियों पर प्रशिक्षित करने की अनुमति देगा। जैसा कि हम व्यवहार में देखेंगे, ज्ञान मॉडल को स्थानांतरित करके हम 95% वर्गीकरण सटीकता प्राप्त कर सकते हैं। चलो शुरू हो जाओ!

मॉडल स्थानांतरण सीखना

2012 में, एलेक्सनेट न्यूरल नेटवर्क ने मशीन लर्निंग की दुनिया में क्रांति ला दी और इमेजनेट लार्ज स्केल विजुअल रिकॉग्निशन चैलेंज को जीतकर वर्गीकरण के लिए कंसॉल्यूशनल न्यूरल नेटवर्क के इस्तेमाल को लोकप्रिय बनाया।

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

कई वर्षों के लिए, तंत्रिका नेटवर्क विकसित किए गए हैं जो एलेक्सनेट - इनसेप्शन और रेसनेट से बेहतर वर्गीकरण कार्य का सामना करते हैं।
इस बात से सहमत हैं कि ImageNet से विशाल डेटासेट पर पहले से ही प्रशिक्षित इन तंत्रिका नेटवर्क का लाभ उठाने में सक्षम होना और बिल्लियों और कुत्तों के लिए अपने वर्गीकरण में उनका उपयोग करना बहुत अच्छा होगा?

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

हमें प्रशिक्षण मॉडल को स्थानांतरित करने की पद्धति को लागू करने के लिए, हमें अपने प्रासंगिक तंत्रिका नेटवर्क की अंतिम परत को बदलना होगा:

हम इस ऑपरेशन को करते हैं क्योंकि प्रत्येक डेटा सेट में आउटपुट कक्षाओं की एक अलग संख्या होती है। उदाहरण के लिए, ImageNet में डेटासेट में 1000 अलग-अलग आउटपुट कक्षाएं हैं। FashionMNIST में 10 कक्षाएं शामिल हैं। हमारे वर्गीकरण डेटासेट में केवल 2 वर्ग हैं - बिल्लियाँ और कुत्ते।

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

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

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

पूर्व-प्रशिक्षित मॉडलों का एक और निर्विवाद लाभ यह है कि हम केवल पिछली परत को काफी कम संख्या में चर के साथ प्रशिक्षण द्वारा प्रशिक्षण के समय को कम करते हैं, न कि पूरे मॉडल को।

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

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

अब जब हम जानते हैं कि प्रशिक्षण मॉडल का स्थानांतरण कैसे काम करता है, तो हमें बस अपने स्वयं के क्लासिफायर में उपयोग के लिए एक पूर्व-प्रशिक्षित तंत्रिका नेटवर्क चुनना होगा! यह हम अगले भाग में करेंगे।

MobileNet

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

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

MobileNet Google द्वारा विकसित किया गया था और ImageNet डेटासेट पर प्रशिक्षित किया गया था।

चूंकि MobileNet को ImageNet डेटासेट से 1,000 वर्गों में प्रशिक्षित किया गया था, MobileNet के पास 1,000 आउटपुट कक्षाएं हैं, दोनों के बजाय हमें ज़रूरत है - एक बिल्ली और एक कुत्ता।

प्रशिक्षण के हस्तांतरण को पूरा करने के लिए, हम एक वर्गीकरण परत के बिना सुविधा वेक्टर को लोड करते हैं:

Tensorflow में, एक लोड किए गए फ़ीचर वेक्टर को एक निश्चित आकार के इनपुट डेटा के साथ एक नियमित Keras परत के रूप में उपयोग किया जा सकता है।

चूंकि MobileNet को ImageNet डेटासेट पर प्रशिक्षित किया गया था, इसलिए हमें उन इनपुट डेटा का आकार लाने की आवश्यकता होगी जो प्रशिक्षण प्रक्रिया में उपयोग किए गए थे। हमारे मामले में, MobileNet को 224x224px निश्चित आकार के RGB चित्रों पर प्रशिक्षित किया गया था।

TensorFlow में TensorFlow Hub नामक एक पूर्व-प्रशिक्षित भंडार होता है।

TensorFlow हब में कुछ पूर्व-प्रशिक्षित मॉडल शामिल हैं जिसमें अंतिम वर्गीकरण परत को तंत्रिका नेटवर्क की वास्तुकला से पहले के उपयोग के लिए बाहर रखा गया था।

आप कई पंक्तियों में कोड में TensorFlow हब का उपयोग कर सकते हैं:

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

आइए देखें कि यह वास्तव में कैसे काम करेगा और उपयुक्त कोड लिखेगा।

कोलैब: स्थानांतरण प्रशिक्षण के साथ बिल्लियों बनाम कुत्ते

रूसी में CoLab और अंग्रेजी में CoLab का लिंक।

TensorFlow हब पूर्व-प्रशिक्षित मॉडल के साथ एक भंडार है जिसे हम उपयोग कर सकते हैं।

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

इस व्यावहारिक भाग में, हम दोनों विकल्पों का परीक्षण करेंगे।

यह लिंक आपको उपलब्ध मॉडल की पूरी सूची का पता लगाने की अनुमति देता है।

कोलाब के इस हिस्से में

हम भविष्यवाणियों के लिए TensorFlow हब मॉडल का उपयोग करेंगे;
हम बिल्लियों और कुत्तों के डेटा सेट के लिए TensorFlow हब-मॉडल का उपयोग करेंगे;
आइए TensorFlow हब से मॉडल का उपयोग करके प्रशिक्षण स्थानांतरित करें।

वर्तमान व्यावहारिक भाग के कार्यान्वयन से आगे बढ़ने से पहले, हम Runtime -> Reset all runtimes... को रीसेट करने की सलाह देते हैं Runtime -> Reset all runtimes...

लाइब्रेरी आयात

इस व्यावहारिक भाग में, हम कई TensorFlow लाइब्रेरी सुविधाओं का उपयोग करेंगे जो अभी तक आधिकारिक रिलीज़ में नहीं हैं। यही कारण है कि हम पहले डेवलपर्स के लिए TensorFlow और TensorFlow हब संस्करण स्थापित करेंगे।

TensorFlow के देव संस्करण को स्थापित करना स्वचालित रूप से नवीनतम स्थापित संस्करण को सक्रिय करता है। इस व्यावहारिक भाग से निपटने के बाद, हम TensorFlow सेटिंग्स को पुनर्स्थापित करने और मेनू आइटम Runtime -> Reset all runtimes... माध्यम से स्थिर संस्करण पर लौटने की सलाह देते हैं Runtime -> Reset all runtimes... इस आदेश को निष्पादित करने से सभी पर्यावरण सेटिंग्स मूल लोगों के लिए रीसेट हो जाएंगी।

 !pip install tf-nightly-gpu !pip install "tensorflow_hub==0.4.0" !pip install -U tensorflow_datasets

निष्कर्ष:

 Requirement already satisfied: absl-py>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (0.8.0) Requirement already satisfied: protobuf>=3.6.1 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (3.7.1) Requirement already satisfied: google-pasta>=0.1.6 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (0.1.7) Collecting tf-estimator-nightly (from tf-nightly-gpu) Downloading https://files.pythonhosted.org/packages/ea/72/f092fc631ef2602fd0c296dcc4ef6ef638a6a773cb9fdc6757fecbfffd33/tf_estimator_nightly-1.14.0.dev2019092201-py2.py3-none-any.whl (450kB) |████████████████████████████████| 450kB 45.9MB/s Requirement already satisfied: numpy<2.0,>=1.16.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (1.16.5) Requirement already satisfied: wrapt>=1.11.1 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (1.11.2) Requirement already satisfied: astor>=0.6.0 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (0.8.0) Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (3.0.1) Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.6/dist-packages (from tf-nightly-gpu) (0.33.6) Requirement already satisfied: h5py in /usr/local/lib/python3.6/dist-packages (from keras-applications>=1.0.8->tf-nightly-gpu) (2.8.0) Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.6/dist-packages (from tb-nightly<1.16.0a0,>=1.15.0a0->tf-nightly-gpu) (3.1.1) Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.6/dist-packages (from tb-nightly<1.16.0a0,>=1.15.0a0->tf-nightly-gpu) (41.2.0) Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.6/dist-packages (from tb-nightly<1.16.0a0,>=1.15.0a0->tf-nightly-gpu) (0.15.6) Installing collected packages: tb-nightly, tf-estimator-nightly, tf-nightly-gpu Successfully installed tb-nightly-1.15.0a20190911 tf-estimator-nightly-1.14.0.dev2019092201 tf-nightly-gpu-1.15.0.dev20190821 Collecting tensorflow_hub==0.4.0 Downloading https://files.pythonhosted.org/packages/10/5c/6f3698513cf1cd730a5ea66aec665d213adf9de59b34f362f270e0bd126f/tensorflow_hub-0.4.0-py2.py3-none-any.whl (75kB) |████████████████████████████████| 81kB 5.0MB/s Requirement already satisfied: protobuf>=3.4.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_hub==0.4.0) (3.7.1) Requirement already satisfied: numpy>=1.12.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_hub==0.4.0) (1.16.5) Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_hub==0.4.0) (1.12.0) Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from protobuf>=3.4.0->tensorflow_hub==0.4.0) (41.2.0) Installing collected packages: tensorflow-hub Found existing installation: tensorflow-hub 0.6.0 Uninstalling tensorflow-hub-0.6.0: Successfully uninstalled tensorflow-hub-0.6.0 Successfully installed tensorflow-hub-0.4.0 Collecting tensorflow_datasets Downloading https://files.pythonhosted.org/packages/6c/34/ff424223ed4331006aaa929efc8360b6459d427063dc59fc7b75d7e4bab3/tensorflow_datasets-1.2.0-py3-none-any.whl (2.3MB) |████████████████████████████████| 2.3MB 4.9MB/s Requirement already satisfied, skipping upgrade: future in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (0.16.0) Requirement already satisfied, skipping upgrade: wrapt in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (1.11.2) Requirement already satisfied, skipping upgrade: dill in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (0.3.0) Requirement already satisfied, skipping upgrade: numpy in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (1.16.5) Requirement already satisfied, skipping upgrade: requests>=2.19.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (2.21.0) Requirement already satisfied, skipping upgrade: tqdm in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (4.28.1) Requirement already satisfied, skipping upgrade: protobuf>=3.6.1 in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (3.7.1) Requirement already satisfied, skipping upgrade: psutil in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (5.4.8) Requirement already satisfied, skipping upgrade: promise in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (2.2.1) Requirement already satisfied, skipping upgrade: absl-py in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (0.8.0) Requirement already satisfied, skipping upgrade: tensorflow-metadata in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (0.14.0) Requirement already satisfied, skipping upgrade: six in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (1.12.0) Requirement already satisfied, skipping upgrade: termcolor in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (1.1.0) Requirement already satisfied, skipping upgrade: attrs in /usr/local/lib/python3.6/dist-packages (from tensorflow_datasets) (19.1.0) Requirement already satisfied, skipping upgrade: idna<2.9,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests>=2.19.0->tensorflow_datasets) (2.8) Requirement already satisfied, skipping upgrade: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests>=2.19.0->tensorflow_datasets) (2019.6.16) Requirement already satisfied, skipping upgrade: chardet<3.1.0,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests>=2.19.0->tensorflow_datasets) (3.0.4) Requirement already satisfied, skipping upgrade: urllib3<1.25,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests>=2.19.0->tensorflow_datasets) (1.24.3) Requirement already satisfied, skipping upgrade: setuptools in /usr/local/lib/python3.6/dist-packages (from protobuf>=3.6.1->tensorflow_datasets) (41.2.0) Requirement already satisfied, skipping upgrade: googleapis-common-protos in /usr/local/lib/python3.6/dist-packages (from tensorflow-metadata->tensorflow_datasets) (1.6.0) Installing collected packages: tensorflow-datasets Successfully installed tensorflow-datasets-1.2.0

हमने पहले भी कुछ आयात देखे और इस्तेमाल किए हैं। नए से आयात tensorflow_hub , जो हमने स्थापित किया था और जिसे हम इस व्यावहारिक भाग में उपयोग करेंगे।

 from __future__ import absolute_import, division, print_function, unicode_literals import matplotlib.pylab as plt import tensorflow as tf tf.enable_eager_execution() import tensorflow_hub as hub import tensorflow_datasets as tfds from tensorflow.keras import layers

निष्कर्ष:

 WARNING:tensorflow: TensorFlow's `tf-nightly` package will soon be updated to TensorFlow 2.0. Please upgrade your code to TensorFlow 2.0: * https://www.tensorflow.org/beta/guide/migration_guide Or install the latest stable TensorFlow 1.X release: * `pip install -U "tensorflow==1.*"` Otherwise your code may be broken by the change.

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

भाग 1: भविष्यवाणियों के लिए TensorFlow Hub MobileNet का उपयोग करें

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

हमारे द्वारा उपयोग किया जाने वाला मॉडल MobileNet v2 है (MobileNet के बजाय, tfhub.dev के साथ किसी भी अन्य tf2 संगत छवि क्लासिफायर मॉडल का उपयोग किया जा सकता है)।

क्लासीफायर डाउनलोड करें

MobileNet मॉडल डाउनलोड करें और उसमें से एक Keras मॉडल बनाएँ। इनपुट पर MobileNet 3 रंग चैनलों (RGB) के साथ आकार में 224x224 पिक्सेल की एक छवि प्राप्त करने की उम्मीद करता है।

 CLASSIFIER_URL = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/2" IMAGE_RES = 224 model = tf.keras.Sequential([ hub.KerasLayer(CLASSIFIER_URL, input_shape=(IMAGE_RES, IMAGE_RES, 3)) ])

एकल छवि पर क्लासिफायर चलाएं

MobileNet को ImageNet डेटासेट पर प्रशिक्षित किया गया है। ImageNet में 1000 आउटपुट क्लास हैं और इनमें से एक वर्ग एक सैन्य वर्दी है। आइए उस छवि को ढूंढें जिस पर सैन्य वर्दी स्थित होगी और जो वर्गीकरण सटीकता को सत्यापित करने के लिए इमेजनेट प्रशिक्षण किट का हिस्सा नहीं होगी।

 import numpy as np import PIL.Image as Image grace_hopper = tf.keras.utils.get_file('image.jpg', 'https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg') grace_hopper = Image.open(grace_hopper).resize((IMAGE_RES, IMAGE_RES)) grace_hopper

निष्कर्ष:

 Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg 65536/61306 [================================] - 0s 0us/step

 grace_hopper = np.array(grace_hopper)/255.0 grace_hopper.shape

निष्कर्ष:

 (224, 224, 3)

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

 result = model.predict(grace_hopper[np.newaxis, ...]) result.shape

निष्कर्ष:

 (1, 1001)

भविष्यवाणी का परिणाम 1,001 तत्वों के आकार के साथ एक वेक्टर था, जहां प्रत्येक मूल्य इस संभावना का प्रतिनिधित्व करता है कि छवि में ऑब्जेक्ट एक निश्चित वर्ग से संबंधित है।

अधिकतम संभाव्यता मान की स्थिति को argmax फ़ंक्शन का उपयोग करके पाया जा सकता है। हालांकि, एक सवाल यह है कि हमने अभी भी उत्तर नहीं दिया है - हम यह कैसे निर्धारित कर सकते हैं कि एक तत्व किस वर्ग के लिए अधिकतम संभावना के साथ है?

 predicted_class = np.argmax(result[0], axis=-1) predicted_class

निष्कर्ष:

निर्णय की भविष्यवाणी

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

 labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt') imagenet_labels = np.array(open(labels_path).read().splitlines()) plt.imshow(grace_hopper) plt.axis('off') predicted_class_name = imagenet_labels[predicted_class] _ = plt.title("Prediction: " + predicted_class_name.title())

निष्कर्ष:

 Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt 16384/10484 [==============================================] - 0s 0us/step

बिंगो! हमारे मॉडल ने सैन्य वर्दी की सही पहचान की।

भाग 2: एक बिल्ली और कुत्ते के डेटासेट के लिए TensorFlow हब मॉडल का उपयोग करें

अब हम MobileNet मॉडल के पूर्ण संस्करण का उपयोग करेंगे और देखेंगे कि यह बिल्लियों और कुत्तों के डेटा सेट से कैसे सामना करेगा।

डेटा सेट

बिल्ली और कुत्ते के डेटा डाउनलोड करने के लिए हम TensorFlow Datasets का उपयोग कर सकते हैं।

 splits = tfds.Split.ALL.subsplit(weighted=(80, 20)) splits, info = tfds.load('cats_vs_dogs', with_info=True, as_supervised=True, split = splits) (train_examples, validation_examples) = splits num_examples = info.splits['train'].num_examples num_classes = info.features['label'].num_classes

निष्कर्ष:

 Downloading and preparing dataset cats_vs_dogs (786.68 MiB) to /root/tensorflow_datasets/cats_vs_dogs/2.0.1... /usr/local/lib/python3.6/dist-packages/urllib3/connectionpool.py:847: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings InsecureRequestWarning) WARNING:absl:1738 images were corrupted and were skipped Dataset cats_vs_dogs downloaded and prepared to /root/tensorflow_datasets/cats_vs_dogs/2.0.1. Subsequent calls will reuse this data.

बिल्ली और कुत्ते के डेटासेट की सभी छवियां समान आकार की नहीं होती हैं।

 for i, example_image in enumerate(train_examples.take(3)): print("Image {} shape: {}".format(i+1, example_image[0].shape))

निष्कर्ष:

 Image 1 shape: (500, 343, 3) Image 2 shape: (375, 500, 3) Image 3 shape: (375, 500, 3)

इसलिए, प्राप्त डेटा सेट से छवियों को एक एकल आकार में कमी की आवश्यकता होती है, जो कि मोबाइलनेट मॉडल इनपुट पर उम्मीद करता है - 224 x 224।

.repeat() फ़ंक्शन और steps_per_epoch यहां आवश्यक नहीं हैं, लेकिन वे आपको प्रति प्रशिक्षण पुनरावृत्ति के बारे में 15 सेकंड बचाने की अनुमति देते हैं, क्योंकि अस्थायी बफर को केवल एक बार सीखने की प्रक्रिया की शुरुआत में शुरू किया जाना है।

 def format_image(image, label): image = tf.image.resize(image, (IMAGE_RES, IMAGE_RES)) / 255.0 return image, label BATCH_SIZE = 32 train_batches = train_examples.shuffle(num_examples//4).map(format_image).batch(BATCH_SIZE).prefetch(1) validation_batches = validation_examples.map(format_image).batch(BATCH_SIZE).prefetch(1)

छवि सेट पर क्लासिफायर चलाएं

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

 image_batch, label_batch = next(iter(train_batches.take(1))) image_batch = image_batch.numpy() label_batch = label_batch.numpy() result_batch = model.predict(image_batch) predicted_class_names = imagenet_labels[np.argmax(result_batch, axis=-1)] predicted_class_names

निष्कर्ष:

 array(['Persian cat', 'mink', 'Siamese cat', 'tabby', 'Bouvier des Flandres', 'dishwasher', 'Yorkshire terrier', 'tiger cat', 'tabby', 'Egyptian cat', 'Egyptian cat', 'tabby', 'dalmatian', 'Persian cat', 'Border collie', 'Newfoundland', 'tiger cat', 'Siamese cat', 'Persian cat', 'Egyptian cat', 'tabby', 'tiger cat', 'Labrador retriever', 'German shepherd', 'Eskimo dog', 'kelpie', 'mink', 'Norwegian elkhound', 'Labrador retriever', 'Egyptian cat', 'computer keyboard', 'boxer'], dtype='<U30')

लेबल बिल्लियों और कुत्तों की नस्लों के नाम के समान हैं। चलो अब हमारी बिल्लियों और कुत्तों के डेटासेट से कुछ चित्र प्रदर्शित करते हैं और उनमें से प्रत्येक पर एक अनुमानित लेबल लगाते हैं।

 plt.figure(figsize=(10, 9)) for n in range(30): plt.subplot(6, 5, n+1) plt.subplots_adjust(hspace=0.3) plt.imshow(image_batch[n]) plt.title(predicted_class_names[n]) plt.axis('off') _ = plt.suptitle("ImageNet predictions")

भाग 3: TensorFlow हब के साथ लर्निंग ट्रांसफर लागू करें

अब एक मॉडल से दूसरे में सीखने को स्थानांतरित करने के लिए TensorFlow हब का उपयोग करें।

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

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

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

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

 URL = 'https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/2' feature_extractor = hub.KerasLayer(URL, input_shape=(IMAGE_RES, IMAGE_RES, 3))

चलो feature_extractor माध्यम से छवियों का एक सेट चलाते हैं और परिणामस्वरूप फ़ॉर्म (आउटपुट प्रारूप) को देखते हैं। 32 - छवियों की संख्या, 1280 - टेंसोरफ्लो हब के साथ पूर्व-प्रशिक्षित मॉडल की अंतिम परत में न्यूरॉन्स की संख्या।

 feature_batch = feature_extractor(image_batch) print(feature_batch.shape)

निष्कर्ष:

 (32, 1280)

हम संपत्ति निष्कर्षण परत में चर "फ्रीज" करते हैं ताकि प्रशिक्षण प्रक्रिया के दौरान वर्गीकरण परत के चर के मूल्यों में केवल परिवर्तन हो।

 feature_extractor.trainable = False

एक वर्गीकरण परत जोड़ें

अब TensorFlow हब से लेयर को tf.keras.Sequential मॉडल में tf.keras.Sequential और एक वर्गीकरण परत जोड़ें।

 model = tf.keras.Sequential([ feature_extractor, layers.Dense(2, activation='softmax') ]) model.summary()

निष्कर्ष:

 Model: "sequential_1" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= keras_layer_1 (KerasLayer) (None, 1280) 2257984 _________________________________________________________________ dense (Dense) (None, 2) 2562 ================================================================= Total params: 2,260,546 Trainable params: 2,562 Non-trainable params: 2,257,984 _________________________________________________________________

ट्रेन का मॉडल

अब हम परिणामस्वरूप मॉडल को प्रशिक्षित करते हैं जिस तरह से हमने compile से पहले प्रशिक्षण के लिए fit किया था।

 model.compile( optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'] ) EPOCHS = 6 history = model.fit(train_batches, epochs=EPOCHS, validation_data=validation_batches)

निष्कर्ष:

 Epoch 1/6 582/582 [==============================] - 77s 133ms/step - loss: 0.2381 - acc: 0.9346 - val_loss: 0.0000e+00 - val_acc: 0.0000e+00 Epoch 2/6 582/582 [==============================] - 70s 120ms/step - loss: 0.1827 - acc: 0.9618 - val_loss: 0.1629 - val_acc: 0.9670 Epoch 3/6 582/582 [==============================] - 69s 119ms/step - loss: 0.1733 - acc: 0.9660 - val_loss: 0.1623 - val_acc: 0.9666 Epoch 4/6 582/582 [==============================] - 69s 118ms/step - loss: 0.1677 - acc: 0.9676 - val_loss: 0.1627 - val_acc: 0.9677 Epoch 5/6 582/582 [==============================] - 68s 118ms/step - loss: 0.1636 - acc: 0.9689 - val_loss: 0.1634 - val_acc: 0.9675 Epoch 6/6 582/582 [==============================] - 69s 118ms/step - loss: 0.1604 - acc: 0.9701 - val_loss: 0.1643 - val_acc: 0.9668

जैसा कि आपने शायद देखा, हम सत्यापन डेटा सेट पर पूर्वानुमानों की ~ 97% सटीकता प्राप्त करने में सक्षम थे। बहुत खूब! वर्तमान दृष्टिकोण ने पहले मॉडल की तुलना में वर्गीकरण सटीकता में काफी वृद्धि की है जिसे हमने खुद को प्रशिक्षित किया और ~ 87% की वर्गीकरण सटीकता प्राप्त की। कारण यह है कि MobileNet विशेषज्ञों द्वारा डिज़ाइन किया गया था और ध्यान से समय की लंबी अवधि में विकसित किया गया था, और फिर ImageNet डेटा के एक अविश्वसनीय बड़े सरणी पर प्रशिक्षित किया गया।

आप इस लिंक पर केरस में अपना खुद का मोबाइलनेट कैसे बना सकते हैं।

चलो प्रशिक्षण और सत्यापन डेटा सेट पर सटीकता और हानि मूल्यों में परिवर्तन के ग्राफ बनाते हैं।

 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.show()

यहां दिलचस्प बात यह है कि सत्यापन डेटा सेट पर परिणाम प्रशिक्षण प्रक्रिया पर सेट किए गए प्रशिक्षण डेटा के परिणामों से बेहतर हैं जो सीखने की प्रक्रिया के बहुत अंत तक हैं।

इस व्यवहार का एक कारण यह है कि सत्यापन डेटासेट पर सटीकता को प्रशिक्षण पुनरावृत्ति के अंत में मापा जाता है, और प्रशिक्षण डाटासेट पर सटीकता को सभी प्रशिक्षण पुनरावृत्तियों का औसत माना जाता है।

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

भविष्यवाणी परिणाम की जाँच करें

पिछले अनुभाग से ग्राफ को दोहराने के लिए, पहले आपको कक्षा के नामों की क्रमबद्ध सूची प्राप्त करनी होगी:

 class_names = np.array(info.features['label'].names) class_names

निष्कर्ष:

 array(['cat', 'dog'], dtype='<U3')

मॉडल के माध्यम से छवियों के साथ ब्लॉक पास करें और परिणामस्वरूप अनुक्रमित को वर्ग नामों में परिवर्तित करें:

 predicted_batch = model.predict(image_batch) predicted_batch = tf.squeeze(predicted_batch).numpy() predicted_ids = np.argmax(predicted_batch, axis=-1) predicted_class_names = class_names[predicted_ids] predicted_class_names

निष्कर्ष:

 array(['cat', 'cat', 'cat', 'cat', 'dog', 'cat', 'dog', 'cat', 'cat', 'cat', 'cat', 'cat', 'dog', 'cat', 'cat', 'dog', 'cat', 'cat', 'cat', 'cat', 'cat', 'cat', 'dog', 'dog', 'dog', 'dog', 'cat', 'cat', 'dog', 'cat', 'cat', 'dog'], dtype='<U3')

आइए सच्चे लेबल पर एक नज़र डालें और भविष्यवाणी करें:

 print(": ", label_batch) print(": ", predicted_ids)

निष्कर्ष:

 : [0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 1] : [0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 1 1 1 0 0 1 0 0 1]

 plt.figure(figsize=(10, 9)) for n in range(30): plt.subplot(6, 5, n+1) plt.subplots_adjust(hspace=0.3) plt.imshow(image_batch[n]) color = "blue" if predicted_ids[n] == label_batch[n] else "red" plt.title(predicted_class_names[n].title(), color=color) plt.axis('off') _ = plt.suptitle("  (: , : )")

दृढ़ तंत्रिका नेटवर्क में गोताखोरी

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

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

बड़ी संख्या में बड़े डेटा सेट और पूर्व-प्रशिक्षित तंत्रिका नेटवर्क के पूर्व-प्रशिक्षित मॉडल के बावजूद, कभी-कभी यह समझना बेहद मुश्किल होता है कि नेटवर्क कैसे काम करता है और वास्तव में यह नेटवर्क क्या सीखता है, खासकर उन लोगों के लिए जिन्हें मशीन सीखने के क्षेत्र में पर्याप्त ज्ञान नहीं है। , , , Inception, . . , , , , .

" Python"
François Chollet. , . Keras, , " " TensorFlow, MXNET Theano. , , . , .

, , .

(training accuracy) . , , , , Inception, .

, , . Inception v3 ( ImageNet) , Kaggle. Inception, , Inception v3 .

10 () 32 , 2292293. 0.3195, — 0.6377. ImageDataGenerator , . GitHub .

, "" , . .

, Inception v3 , .

— . .

, () . (), , , , . , , , , .

ReLU- . , ReLU(z) = max(0, z) .

, , , , , , , , .. , . "" () , , , .

"" . .

, Inveption V3 :

, . , , , , .. , , . , , , "" ( , ).

, , , . , .

Class Activation Map ( ). CAM . 2D , .

, . , , Mixed- Inception V3-, . () , .

, , . , , . , . , , , , .

, "" - . . .

, , .

:

Colab Colab .

TensorFlow Hub

TensorFlow Hub , .

. , , , .

Runtime -> Reset all runtimes...

, :

 from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np import matplotlib.pyplot as plt import tensorflow as tf tf.enable_eager_execution() import tensorflow_hub as hub import tensorflow_datasets as tfds from tensorflow.keras import layers

 WARNING:tensorflow: The TensorFlow contrib module will not be included in TensorFlow 2.0. For more information, please see: * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md * https://github.com/tensorflow/addons * https://github.com/tensorflow/io (for I/O related ops) If you depend on functionality not listed there, please file an issue.

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

TensorFlow Datasets

TensorFlow Datasets. , — tf_flowers . , . tfds.splits (70%) (30%). tfds.load . tfds.load , , .

 splits = tfds.Split.TRAIN.subsplit([70, 30]) (training_set, validation_set), dataset_info = tfds.load('tf_flowers', with_info=True, as_supervised=True, split=splits)

 Downloading and preparing dataset tf_flowers (218.21 MiB) to /root/tensorflow_datasets/tf_flowers/1.0.0... Dl Completed... 1/|/100% 1/1 [00:07<00:00, 3.67s/ url] Dl Size... 218/|/100% 218/218 [00:07<00:00, 30.69 MiB/s] Extraction completed... 1/|/100% 1/1 [00:07<00:00, 7.05s/ file] Dataset tf_flowers downloaded and prepared to /root/tensorflow_datasets/tf_flowers/1.0.0. Subsequent calls will reuse this data.

, , () , , — .

 num_classes = dataset_info.features['label'].num_classes num_training_examples = 0 num_validation_examples = 0 for example in training_set: num_training_examples += 1 for example in validation_set: num_validation_examples += 1 print('Total Number of Classes: {}'.format(num_classes)) print('Total Number of Training Images: {}'.format(num_training_examples)) print('Total Number of Validation Images: {} \n'.format(num_validation_examples))

 Total Number of Classes: 5 Total Number of Training Images: 2590 Total Number of Validation Images: 1080

— .

 for i, example in enumerate(training_set.take(5)): print('Image {} shape: {} label: {}'.format(i+1, example[0].shape, example[1]))

 Image 1 shape: (226, 240, 3) label: 0 Image 2 shape: (240, 145, 3) label: 2 Image 3 shape: (331, 500, 3) label: 2 Image 4 shape: (240, 320, 3) label: 0 Image 5 shape: (333, 500, 3) label: 1

— , MobilNet v2 — 224224 (grayscale). image () label () .

 IMAGE_RES = 224 def format_image(image, label): image = tf.image.resize(image, (IMAGE_RES, IMAGE_RES))/255.0 return image, label BATCH_SIZE = 32 train_batches = training_set.shuffle(num_training_examples//4).map(format_image).batch(BATCH_SIZE).prefetch(1) validation_batches = validation_set.map(format_image).batch(BATCH_SIZE).prefetch(1)

TensorFlow Hub

TensorFlow Hub . , , .

feature_extractor MobileNet v2. , TensorFlow Hub ( ) . . tf2-preview/mobilenet_v2/feature_vector , URL MobileNet v2 . feature_extractor hub.KerasLayer input_shape .

 URL = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/4" feature_extractor = hub.KerasLayer(URL, input_shape=(IMAGE_RES, IMAGE_RES, 3))

, :

 feature_extractor.trainable = False

, . . .

 model = tf.keras.Sequential([ feature_extractor, layers.Dense(num_classes, activation='softmax') ]) model.summary()

 Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= keras_layer (KerasLayer) (None, 1280) 2257984 _________________________________________________________________ dense (Dense) (None, 5) 6405 ================================================================= Total params: 2,264,389 Trainable params: 6,405 Non-trainable params: 2,257,984

, .

 model.compile( optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) EPOCHS = 6 history = model.fit(train_batches, epochs=EPOCHS, validation_data=validation_batches)

 Epoch 1/6 81/81 [==============================] - 17s 216ms/step - loss: 0.7765 - acc: 0.7170 - val_loss: 0.0000e+00 - val_acc: 0.0000e+00 Epoch 2/6 81/81 [==============================] - 12s 147ms/step - loss: 0.3806 - acc: 0.8757 - val_loss: 0.3485 - val_acc: 0.8833 Epoch 3/6 81/81 [==============================] - 12s 146ms/step - loss: 0.3011 - acc: 0.9031 - val_loss: 0.3190 - val_acc: 0.8907 Epoch 4/6 81/81 [==============================] - 12s 147ms/step - loss: 0.2527 - acc: 0.9205 - val_loss: 0.3031 - val_acc: 0.8917 Epoch 5/6 81/81 [==============================] - 12s 148ms/step - loss: 0.2177 - acc: 0.9371 - val_loss: 0.2933 - val_acc: 0.8972 Epoch 6/6 81/81 [==============================] - 12s 146ms/step - loss: 0.1905 - acc: 0.9456 - val_loss: 0.2870 - val_acc: 0.9000

~90% 6 , ! , , ~76% 80 . , MobilNet v2 .

 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='Training Accuracy') plt.plot(epochs_range, val_acc, label='Validation Accuracy') plt.legend(loc='lower right') plt.title('Training and Validation Accuracy') plt.subplot(1, 2, 2) plt.plot(epochs_range, loss, label='Training Loss') plt.plot(epochs_range, val_loss, label='Validation Loss') plt.legend(loc='upper right') plt.title('Training and Validation Loss') plt.show()

, , .

- MobileNet, . ( augmentation), . .

NumPy. , .

 class_names = np.array(dataset_info.features['label'].names) print(class_names)

 ['dandelion' 'daisy' 'tulips' 'sunflowers' 'roses']

next() image_batch ( ) label_batch ( ). image_batch label_batch NumPy .numpy() . .predict() . np.argmax() . .

 image_batch, label_batch = next(iter(train_batches)) image_batch = image_batch.numpy() label_batch = label_batch.numpy() predicted_batch = model.predict(image_batch) predicted_batch = tf.squeeze(predicted_batch).numpy() predicted_ids = np.argmax(predicted_batch, axis=-1) predicted_class_names = class_names[predicted_ids] print(predicted_class_names)

 ['sunflowers' 'roses' 'tulips' 'tulips' 'daisy' 'dandelion' 'tulips' 'sunflowers' 'daisy' 'daisy' 'tulips' 'daisy' 'daisy' 'tulips' 'tulips' 'tulips' 'dandelion' 'dandelion' 'tulips' 'tulips' 'dandelion' 'roses' 'daisy' 'daisy' 'dandelion' 'roses' 'daisy' 'tulips' 'dandelion' 'dandelion' 'roses' 'dandelion']

 print("Labels: ", label_batch) print("Predicted labels: ", predicted_ids)

 Labels: [3 4 2 2 1 0 2 3 1 1 2 1 1 2 2 2 0 0 2 2 0 4 1 1 0 4 1 2 0 0 4 0] Predicted labels: [3 4 2 2 1 0 2 3 1 1 2 1 1 2 2 2 0 0 2 2 0 4 1 1 0 4 1 2 0 0 4 0]

 plt.figure(figsize=(10,9)) for n in range(30): plt.subplot(6,5,n+1) plt.subplots_adjust(hspace = 0.3) plt.imshow(image_batch[n]) color = "blue" if predicted_ids[n] == label_batch[n] else "red" plt.title(predicted_class_names[n].title(), color=color) plt.axis('off') _ = plt.suptitle("Model predictions (blue: correct, red: incorrect)")

Inception-

TensorFlow Hub tf2-preview/inception_v3/feature_vector . Inception V3 . , Inception V3 . , Inception V3 299299 . Inception V3 MobileNet V2.

 IMAGE_RES = 299 (training_set, validation_set), dataset_info = tfds.load('tf_flowers', with_info=True, as_supervised=True, split=splits) train_batches = training_set.shuffle(num_training_examples//4).map(format_image).batch(BATCH_SIZE).prefetch(1) validation_batches = validation_set.map(format_image).batch(BATCH_SIZE).prefetch(1) URL = "https://tfhub.dev/google/tf2-preview/inception_v3/feature_vector/4" feature_extractor = hub.KerasLayer(URL, input_shape=(IMAGE_RES, IMAGE_RES, 3), trainable=False) model_inception = tf.keras.Sequential([ feature_extractor, tf.keras.layers.Dense(num_classes, activation='softmax') ]) model_inception.summary()

 Model: "sequential_1" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= keras_layer_1 (KerasLayer) (None, 2048) 21802784 _________________________________________________________________ dense_1 (Dense) (None, 5) 10245 ================================================================= Total params: 21,813,029 Trainable params: 10,245 Non-trainable params: 21,802,784

 model_inception.compile( optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) EPOCHS = 6 history = model_inception.fit(train_batches, epochs=EPOCHS, validation_data=validation_batches)

 Epoch 1/6 81/81 [==============================] - 44s 541ms/step - loss: 0.7594 - acc: 0.7309 - val_loss: 0.0000e+00 - val_acc: 0.0000e+00 Epoch 2/6 81/81 [==============================] - 35s 434ms/step - loss: 0.3927 - acc: 0.8772 - val_loss: 0.3945 - val_acc: 0.8657 Epoch 3/6 81/81 [==============================] - 35s 434ms/step - loss: 0.3074 - acc: 0.9120 - val_loss: 0.3586 - val_acc: 0.8769 Epoch 4/6 81/81 [==============================] - 35s 434ms/step - loss: 0.2588 - acc: 0.9282 - val_loss: 0.3385 - val_acc: 0.8796 Epoch 5/6 81/81 [==============================] - 35s 436ms/step - loss: 0.2252 - acc: 0.9375 - val_loss: 0.3256 - val_acc: 0.8824 Epoch 6/6 81/81 [==============================] - 35s 435ms/step - loss: 0.1996 - acc: 0.9440 - val_loss: 0.3164 - val_acc: 0.8861

परिणाम

. :

: , . .
: . "" , , .
MobileNet: Google, . MobileNet .

MobileNet . . MobileNet .

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

दृढ़ तंत्रिका नेटवर्क में विसर्जन: सीखने का स्थानांतरण

सामग्री

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

परिचय

मॉडल स्थानांतरण सीखना

MobileNet

कोलैब: स्थानांतरण प्रशिक्षण के साथ बिल्लियों बनाम कुत्ते

दृढ़ तंत्रिका नेटवर्क में गोताखोरी

:

परिणाम

More articles: