1. खास जानकारी
इस लैब में, आपको आधुनिक कॉन्वोलूशनल आर्किटेक्चर के बारे में जानकारी मिलेगी. साथ ही, अपनी जानकारी का इस्तेमाल करके "स्क्वीज़नेट" नाम के आसान, लेकिन असरदार कन्वर्ज़न को लागू करना होगा.
इस लैब में, कॉन्वोल्यूशनल न्यूरल नेटवर्क के बारे में ज़रूरी सैद्धांतिक जानकारी दी गई है. यह डीप लर्निंग के बारे में जानने वाले डेवलपर के लिए एक अच्छा शुरुआती पॉइंट है.
यह लैब "TPU पर केरस" सीरीज़ का चौथा भाग है. इन चरणों को नीचे दिए गए क्रम में या अलग-अलग क्रम में पूरा किया जा सकता है.
- टीपीयू की स्पीड वाली डेटा पाइपलाइन: tf.data.Dataset और TFRecords
- ट्रांसफ़र लर्निंग की मदद से, अपना पहला Keras मॉडल बनाना
- केरास और टीपीयू के साथ कन्वलूशनल न्यूरल नेटवर्क
- [THIS LAB] Keras और TPU के साथ मॉडर्न कन्वर्ज़न, स्क्विज़नेट, Xception
आपको क्या सीखने को मिलेगा
- Keras की फ़ंक्शनल स्टाइल में महारत हासिल करने के लिए
- स्क्वीज़नेट आर्किटेक्चर का इस्तेमाल करके मॉडल बनाने के लिए
- TPU का इस्तेमाल करके, अपने सिस्टम को तेज़ी से ट्रेनिंग देना और उसे दोहराना
- tf.data.dataset की मदद से, डेटा को बेहतर बनाने की सुविधा को लागू करने के लिए
- TPU पर पहले से ट्रेन किए गए बड़े मॉडल (Xception) को बेहतर बनाने के लिए
सुझाव, राय या शिकायत
अगर आपको इस कोड लैब में कुछ गड़बड़ी दिखती है, तो कृपया हमें बताएं. GitHub की समस्याओं [ सुझाव/राय देने या शिकायत करने के लिए लिंक] के ज़रिए सुझाव, शिकायत या राय दी जा सकती है.
2. Google Colaboratory क्विक स्टार्ट
यह लैब, Google Collaboratory का इस्तेमाल करता है और आपको अपनी ओर से किसी सेटअप की ज़रूरत नहीं होती. Colaboratory, सीखने-सिखाने के लिए एक ऑनलाइन नोटबुक प्लैटफ़ॉर्म है. इसमें सीपीयू, जीपीयू, और TPU की मुफ़्त ट्रेनिंग दी जाती है.
Colaboratory के बारे में जानने के लिए, इस सैंपल नोटबुक को खोला जा सकता है और कुछ सेल को चलाया जा सकता है.
कोई TPU बैकएंड चुनें
Colab मेन्यू में, रनटाइम > रनटाइम का टाइप बदलें को चुनें. इसके बाद, TPU चुनें. इस कोड लैब में, आपको हार्डवेयर की मदद से तेज़ी से ट्रेनिंग देने वाली सुविधा के लिए, बेहतर TPU (टेंसर प्रोसेसिंग यूनिट) का इस्तेमाल करना होगा. पहली बार एक्ज़ीक्यूशन करने पर, रनटाइम से कनेक्शन अपने-आप हो जाएगा. इसके अलावा, सबसे ऊपर दाएं कोने में मौजूद "कनेक्ट करें" बटन का इस्तेमाल भी किया जा सकता है.
नोटबुक चलाना
सेल पर क्लिक करके और Shift-ENTER का इस्तेमाल करके एक-एक करके सेल एक्ज़ीक्यूट करें. रनटाइम > सभी चलाएं का इस्तेमाल करके भी, पूरी नोटबुक को चलाया जा सकता है
विषय सूची
सभी नोटबुक में विषय सूची होती है. इसे खोलने के लिए, बाईं ओर मौजूद काले रंग के ऐरो का इस्तेमाल करें.
छिपी हुई सेल
कुछ सेल में सिर्फ़ उनका टाइटल दिखेगा. यह सुविधा, Colab की नोटबुक में ही उपलब्ध है. अंदर का कोड देखने के लिए उन पर दो बार क्लिक करें, लेकिन आम तौर पर यह बहुत दिलचस्प नहीं होता. आम तौर पर, सहायता या विज़ुअलाइज़ेशन फ़ंक्शन. इन सेल में मौजूद फ़ंक्शन तय करने के लिए, आपको इन्हें फिर से चलाना होगा.
पुष्टि करना
Colab, Google Cloud Storage की आपकी निजी बकेट को ऐक्सेस कर सकता है. इसके लिए, ज़रूरी है कि आपने अनुमति वाले किसी खाते की मदद से पुष्टि की हो. ऊपर दिया गया कोड स्निपेट, पुष्टि करने की प्रोसेस को ट्रिगर करेगा.
3. [जानकारी] टेंसर प्रोसेसिंग यूनिट (TPU) क्या हैं?
कम शब्दों में
Keras में TPU पर मॉडल को ट्रेनिंग देने के लिए कोड (और TPU उपलब्ध न होने पर, जीपीयू या सीपीयू पर फ़ॉलबैक करना):
try: # detect TPUs
tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines
# use TPUStrategy scope to define model
with strategy.scope():
model = tf.keras.Sequential( ... )
model.compile( ... )
# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)
आज हम TPU का इस्तेमाल, इंटरैक्टिव स्पीड (हर ट्रेनिंग रन के लिए मिनट) के हिसाब से फूलों की कैटगरी तय करने वाला सिस्टम बनाने और उसे ऑप्टिमाइज़ करने के लिए करेंगे.
TPU क्यों ?
मॉडर्न जीपीयू, प्रोग्राम किए जा सकने वाले "कोर" के आधार पर व्यवस्थित किए जाते हैं. यह एक बेहद सुविधाजनक आर्किटेक्चर है. इसकी मदद से, वे 3D रेंडरिंग, डीप लर्निंग, फ़िज़िकल सिम्युलेशन वगैरह जैसे कई काम कर सकते हैं. दूसरी ओर, टीपीयू में किसी खास मैट्रिक्स मल्टीप्लाई यूनिट के साथ क्लासिक वेक्टर प्रोसेसर जोड़ा जाता है. साथ ही, यह ऐसे किसी भी टास्क में बेहतरीन परफ़ॉर्म करता है जिसमें बड़े मैट्रिक्स मल्टीप्लाई होते हैं. जैसे, न्यूरल नेटवर्क.
इलस्ट्रेशन: मैट्रिक्स गुणा के तौर पर एक घनी न्यूरल नेटवर्क लेयर, जिसमें एक साथ आठ इमेज का बैच, न्यूरल नेटवर्क के ज़रिए प्रोसेस किया गया है. कृपया एक लाइन x कॉलम को गुणा करें और देखें कि यह असल में किसी इमेज की सभी पिक्सल वैल्यू का वेटेड योग कर रहा है या नहीं. कॉन्वोल्यूशनल लेयर को मैट्रिक्स के गुणन के तौर पर भी दिखाया जा सकता है. हालांकि, यह थोड़ा मुश्किल है ( पहले सेक्शन में यहां इसकी जानकारी दी गई है).
हार्डवेयर
एमएक्सयू और वीपीयू
TPU v2 कोर, मैट्रिक्स मल्टीप्लाई यूनिट (एमएक्सयू) से बना होता है, जो मैट्रिक्स मल्टीप्लिकेशन और वेक्टर प्रोसेसिंग यूनिट (वीपीयू) को अन्य सभी कामों के लिए इस्तेमाल करता है. जैसे, ऐक्टिवेशन, सॉफ़्टमैक्स वगैरह. यह वीपीयू, float32 और int32 कंप्यूटेशन को हैंडल करता है. दूसरी ओर, MXU मिश्रित सटीक 16-32 बिट फ़्लोटिंग पॉइंट फ़ॉर्मैट में काम करता है.
मिक्स्ड प्रिसीज़न फ़्लोटिंग पॉइंट और bfloat16
MXU, bfloat16 इनपुट और float32 आउटपुट का इस्तेमाल करके, मैट्रिक्स के गुणन की गणना करता है. इंटरमीडिएट इकट्ठा करने की प्रोसेस, float32 सटीक अंकों में की जाती है.
न्यूरल नेटवर्क ट्रेनिंग में, फ़्लोटिंग पॉइंट के कम सटीक होने की वजह से आने वाले शोर का कोई असर नहीं होता. कुछ मामलों में शोर की वजह से, ऑप्टिमाइज़र को इकट्ठा करने में भी मदद मिलती है. कैलकुलेशन को तेज़ करने के लिए, आम तौर पर 16-बिट फ़्लोटिंग पॉइंट प्रिसीज़न का इस्तेमाल किया जाता है. हालांकि, float16 और float32 फ़ॉर्मैट की रेंज बहुत अलग होती है. आम तौर पर, float32 से float16 पर सटीक वैल्यू को कम करने पर, ओवर और अंडरफ़्लो की समस्याएं आती हैं. समाधान मौजूद हैं, लेकिन float16 के काम करने के लिए और काम करने की ज़रूरत है.
यही वजह है कि Google ने TPU में bfloat16 फ़ॉर्मैट पेश किया है. bfloat16, छोटा किया हुआ float32 है, जो float32 की तरह ही समान एक्सपोनेंट बिट और रेंज है. इसमें यह बात भी जोड़ी गई है कि TPU, bfloat16 इनपुट की मदद से मिले-जुले सटीक तरीके से मैट्रिक्स मल्टीप्लिकेशन को कंप्यूट करते हैं, लेकिन float32 आउटपुट. इसका मतलब है कि आम तौर पर, कम सटीक परफ़ॉर्मेंस का फ़ायदा पाने के लिए, कोड में किसी तरह के बदलाव की ज़रूरत नहीं होती.
सिस्टोलिक ऐरे
MXU, हार्डवेयर में मैट्रिक्स के गुणन को लागू करता है. इसके लिए, "सिस्टोलिक ऐरे" आर्किटेक्चर का इस्तेमाल किया जाता है. इसमें डेटा एलिमेंट, हार्डवेयर कंप्यूटेशन यूनिट के ऐरे से फ़्लो करते हैं. (चिकित्सा में, "सिस्टोलिक" का मतलब दिल के संकुचन और खून के प्रवाह से है, यहां डेटा के प्रवाह तक.)
मैट्रिक्स के गुणा करने का बुनियादी एलिमेंट, एक मैट्रिक्स की लाइन और दूसरी मैट्रिक्स के कॉलम के बीच का डॉट प्रॉडक्ट होता है. इस सेक्शन में सबसे ऊपर दी गई इमेज देखें. किसी मैट्रिक्स गुणा Y=X*W के लिए, नतीजे का एक एलिमेंट यह होगा:
Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]
जीपीयू पर, इस डॉट प्रॉडक्ट को जीपीयू "कोर" में प्रोग्राम किया जाएगा और फिर नतीजे के तौर पर दिखने वाले मैट्रिक्स की हर वैल्यू को एक साथ आज़माने और कंप्यूट करने के लिए, जितने चाहें उतने "कोर" को एक्ज़ीक्यूट किया जाएगा. अगर नतीजा देने वाला मैट्रिक्स 128x128 बड़ा है, तो इसके लिए 128x128=16K "कोर" उपलब्ध होने चाहिए, जो आम तौर पर मुमकिन नहीं है. सबसे बड़े जीपीयू में करीब 4,000 कोर होते हैं. वहीं दूसरी ओर, TPU, MXU में कंप्यूट यूनिट के लिए कम से कम हार्डवेयर का इस्तेमाल करता है. इसमें सिर्फ़ bfloat16 x bfloat16 => float32 मल्टी-अक्युमिलेटर हैं, कुछ और नहीं. ये तरीके इतने छोटे होते हैं कि TPU इनमें से 16K रिज़ॉल्यूशन, 128x128 MXU में लागू कर सकता है. साथ ही, इस मैट्रिक्स गुणा को एक ही बार में प्रोसेस कर सकता है.
इमेज: MXU सिस्टोलिक ऐरे. कंप्यूट एलिमेंट, मल्टी-अक्युमिलेटर होते हैं. एक मैट्रिक्स की वैल्यू अरे (लाल बिंदु) में लोड होती हैं. अन्य मैट्रिक की वैल्यू, ऐरे (ग्रे बिंदु) से होकर बहती हैं. वर्टिकल लाइनें, वैल्यू को ऊपर की ओर ले जाती हैं. हॉरिज़ॉन्टल लाइनें, आंशिक योग को लागू करती हैं. यह उपयोगकर्ता के लिए एक एक्सरसाइज़ है, ताकि वह पुष्टि कर सके कि डेटा अरे में फ़्लो होने पर, आपको दाईं ओर मैट्रिक के गुणन का नतीजा मिलता है.
इसके अलावा, MXU में डॉट प्रॉडक्ट का हिसाब लगाए जाने के दौरान, इंटरमीडिएट योग आस-पास की कंप्यूट यूनिटों के बीच आसानी से फ़्लोट करते हैं. उन्हें मेमोरी या रजिस्टर फ़ाइल में सेव और उससे वापस पाने की ज़रूरत नहीं होती. आखिरी नतीजा यह है कि TPU सिस्टोलिक अरे आर्किटेक्चर को बहुत ज़्यादा सघनता और पावर का फ़ायदा मिलता है. साथ ही, मैट्रिक्स गुणन की गणना करते समय जीपीयू पर गति का अच्छा-सा फ़ायदा मिलता है.
क्लाउड टीपीयू
Google Cloud Platform पर "Cloud TPU v2" का अनुरोध करने पर, आपको एक वर्चुअल मशीन (VM) मिलती है. इसमें पीसीआई से जुड़ा TPU बोर्ड होता है. TPU बोर्ड में, ड्यूअल-कोर TPU चिप होते हैं. हर TPU कोर में एक VPU (वेक्टर प्रोसेसिंग यूनिट) और 128x128 MXU (मैट्रिक्स गुणा यूनिट) मौजूद होता है. इसके बाद, आम तौर पर इस "Cloud TPU" को नेटवर्क के ज़रिए उस वीएम से कनेक्ट किया जाता है जिसने इसका अनुरोध किया है. इसलिए, पूरी तस्वीर कुछ ऐसी दिखती है:
इलस्ट्रेशन: नेटवर्क से जुड़े "Cloud TPU" ऐक्सेलरेटर के साथ आपकी वर्चुअल मशीन (वीएम). "Cloud TPU", वर्चुअल मशीन (वीएम) से बना होता है. इस पर पीसीआई से जुड़ा TPU बोर्ड होता है. इस पर चार ड्यूअल-कोर TPU चिप मौजूद होते हैं.
TPU पॉड
Google के डेटा सेंटर में, TPU, हाई-परफ़ॉर्मेंस कंप्यूटिंग (एचपीसी) के इंटरकनेक्ट से जुड़े होते हैं. यह उन्हें एक बहुत बड़े एक्सेलरेटर के तौर पर दिखा सकता है. Google इन्हें पॉड कहता है. इनमें 512 TPU v2 कोर या 2048 TPU v3 कोर तक शामिल हो सकते हैं..
इमेज: TPU v3 पॉड. एचपीसी इंटरकनेक्ट के ज़रिए कनेक्ट किए गए टीपीयू बोर्ड और रैक.
ट्रेनिंग के दौरान, ऑल-रिड्यूस एल्गोरिदम का इस्तेमाल करके, TPU कोर के बीच ग्रेडिएंट एक्सचेंज किए जाते हैं ( OK-reduce यहां बेहतर तरीके से बताया गया है). जिस मॉडल को ट्रेनिंग दी जा रही है वह बड़े बैच साइज़ पर ट्रेनिंग करके, हार्डवेयर का फ़ायदा ले सकता है.
इलस्ट्रेशन: Google TPU के 2-D टॉरॉइडल मेश एचपीसी नेटवर्क पर, ऑल-रिड्यूस एल्गोरिदम का इस्तेमाल करके, ट्रेनिंग के दौरान ग्रेडिएंट को सिंक करना.
सॉफ़्टवेयर
बड़े बैच साइज़ की ट्रेनिंग
टीपीयू के लिए, हर टीपीयू कोर के लिए 128 डेटा आइटम का बैच साइज़ आदर्श होता है. हालांकि, हर टीपीयू कोर के लिए आठ डेटा आइटम से भी हार्डवेयर का अच्छा इस्तेमाल किया जा सकता है. याद रखें कि एक Cloud TPU में आठ कोर होते हैं.
इस कोड लैब में, हम Keras API का इस्तेमाल करेंगे. Keras में, आपका तय किया गया बैच, पूरे TPU का ग्लोबल बैच साइज़ होता है. आपके बैच अपने-आप आठ में बंट जाएंगे और TPU के 8 कोर पर चलते रहेंगे.
परफ़ॉर्मेंस से जुड़ी अन्य सलाह के लिए, TPU की परफ़ॉर्मेंस गाइड देखें. बहुत बड़े बैच साइज़ के लिए, कुछ मॉडल में खास ध्यान देने की ज़रूरत पड़ सकती है. ज़्यादा जानकारी के लिए, LARSOptimizer देखें.
अंदरूनी जानकारी: XLA
Tensorflow प्रोग्राम, कैलकुलेशन ग्राफ़ तय करते हैं. TPU, सीधे Python कोड नहीं चलाता है. यह आपके Tensorflow प्रोग्राम के हिसाब से कंप्यूटेशन ग्राफ़ चलाता है. हुड के तहत, XLA (एलिरेटेड लीनियर अलजेब्रा कंपाइलर) नाम का एक कंपाइलर कंप्यूटेशन नोड के Tensorflow ग्राफ़ को TPU मशीन कोड में बदल देता है. यह कंपाइलर आपके कोड और मेमोरी लेआउट पर कई बेहतर ऑप्टिमाइज़ेशन भी करता है. TPU को काम भेजते ही, डेटा कंपाइल हो जाता है. आपको अपनी बिल्ड चेन में XLA को साफ़ तौर पर शामिल करने की ज़रूरत नहीं है.
उदाहरण: TPU पर चलाने के लिए, आपके Tensorflow प्रोग्राम से तय किए गए कैलकुलेशन ग्राफ़ को पहले XLA (Accelerated Linear Algebra compiler) के तौर पर बदला जाता है. इसके बाद, XLA उसे TPU मशीन कोड में कंपाइल करता है.
Keras में TPU का इस्तेमाल करना
TensorFlow 2.1 के बाद से, TPU, Keras API के साथ काम करते हैं. Keras की सहायता, TPU और TPU पॉड पर काम करती है. यहां एक ऐसा उदाहरण दिया गया है जो टीपीयू, जीपीयू, और सीपीयू पर काम करता है:
try: # detect TPUs
tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines
# use TPUStrategy scope to define model
with strategy.scope():
model = tf.keras.Sequential( ... )
model.compile( ... )
# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)
इस कोड स्निपेट में:
TPUClusterResolver().connect(), नेटवर्क पर TPU ढूंढता है. यह Google Cloud के ज़्यादातर सिस्टम (एआई प्लैटफ़ॉर्म जॉब, Colaboratory, Kubeflow, और 'ctpu up' टूल की मदद से बनाए गए डीप लर्निंग वीएम) पर पैरामीटर के बिना काम करता है. TPU_NAME के एनवायरमेंट वैरिएबल की वजह से, इन सिस्टम को यह पता होता है कि उनका TPU कहां है. अगर आपने TPU को मैन्युअल तरीके से बनाया है, तो उस वीएम पर TPU_NAME एनवायरमेंट वैरिएबल सेट करें जिसका इस्तेमाल किया जा रहा है या साफ़ तौर पर पैरामीटर के साथTPUClusterResolverको कॉल करें:TPUClusterResolver(tp_uname, zone, project)TPUStrategyवह हिस्सा है जो डिस्ट्रिब्यूशन और "all-reduce" ग्रेडिएंट सिंक्रोनाइज़ेशन एल्गोरिदम को लागू करता है.- रणनीति को एक स्कोप की मदद से लागू किया जाता है. मॉडल को रणनीति के स्कोप() के तहत तय किया जाना चाहिए.
tpu_model.fitफ़ंक्शन, TPU ट्रेनिंग के लिए इनपुट के तौर पर tf.data.Dataset ऑब्जेक्ट का इस्तेमाल करता है.
TPU पर मॉडल को पोर्ट करने से जुड़े सामान्य काम
- Tensorflow मॉडल में डेटा लोड करने के कई तरीके हैं, लेकिन TPU के लिए,
tf.data.DatasetAPI का इस्तेमाल करना ज़रूरी है. - TPU बहुत तेज़ी से काम करते हैं. जब इन पर चलाया जाता है, तो डेटा का डेटा घुलने-मिलने में मुश्किल हो जाता है. TPU की परफ़ॉर्मेंस से जुड़ी गाइड में, डेटा की रुकावटों का पता लगाने और परफ़ॉर्मेंस से जुड़ी अन्य सलाह पाने के लिए टूल दिए गए हैं.
- int8 या int16 नंबर को int32 के तौर पर माना जाता है. टीपीयू में, 32 बिट से कम पर काम करने वाला इंटिजर हार्डवेयर नहीं होता.
- TensorFlow की कुछ कार्रवाइयां काम नहीं करतीं. सूची यहां दी गई है. अच्छी बात यह है कि यह सीमा सिर्फ़ ट्रेनिंग कोड पर लागू होती है. इसका मतलब है कि आपके मॉडल के फ़ॉरवर्ड और बैकवर्ड पास पर. अब भी अपनी डेटा इनपुट पाइपलाइन में सभी Tensorflow ऑपरेशन का इस्तेमाल किया जा सकता है, क्योंकि यह सीपीयू पर लागू होगा.
- TPU पर
tf.py_funcका इस्तेमाल नहीं किया जा सकता.
4. [INFO] न्यूरल नेटवर्क क्लासिफ़ायर 101
कम शब्दों में
अगर अगले पैराग्राफ़ में बोल्ड में दिए गए सभी शब्दों के बारे में आपको पहले से पता है, तो अगले अभ्यास पर जाएं. अगर आपने अभी डीप लर्निंग शुरू की है, तो आपका स्वागत है. कृपया आगे पढ़ें.
लेयर के क्रम में बनाए गए मॉडल के लिए, Keras Sequential API उपलब्ध कराता है. उदाहरण के लिए, तीन डेंस लेयर का इस्तेमाल करके इमेज को अलग-अलग कैटगरी में बांटने वाले मॉडल को Keras में इस तरह लिखा जा सकता है:
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
tf.keras.layers.Dense(500, activation="relu"),
tf.keras.layers.Dense(50, activation="relu"),
tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])
# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy']) # % of correct answers
# train the model
model.fit(dataset, ... )
डेंस न्यूरल नेटवर्क
यह इमेज को कैटगरी में बांटने का सबसे आसान न्यूरल नेटवर्क है. यह लेयर में व्यवस्थित "न्यूरॉन" से बना होता है. पहली लेयर, इनपुट डेटा को प्रोसेस करती है और अपने आउटपुट को अन्य लेयर में फ़ीड करती है. इसे "डेंस" इसलिए कहा जाता है, क्योंकि हर न्यूरॉन पिछली लेयर के सभी न्यूरॉन से जुड़ा होता है.
किसी इमेज को ऐसे नेटवर्क में फ़ीड किया जा सकता है. इसके लिए, सभी पिक्सल की आरजीबी वैल्यू को एक लॉन्ग वेक्टर में फ़्लैट करके उसे इनपुट के तौर पर इस्तेमाल करें. यह इमेज पहचानने के लिए सबसे अच्छी तकनीक नहीं है, लेकिन हम इसे बाद में बेहतर बनाने की कोशिश करेंगे.
न्यूरॉन, ऐक्टिवेशन, RELU
एक "न्यूरॉन" अपने सभी इनपुट के वेटेड योग की गणना करता है, "बायस" नाम की एक वैल्यू जोड़ता है, और एक तथाकथित "ऐक्टिवेशन फ़ंक्शन" के ज़रिए नतीजे को फ़ीड करता है. शुरुआत में वज़न और पक्ष के बारे में जानकारी नहीं है. इन्हें रैंडम तरीके से शुरू किया जाएगा और बहुत सारे जाने-पहचाने डेटा पर न्यूरल नेटवर्क को ट्रेनिंग देकर, "सीखा" जाएगा.
सबसे ज़्यादा लोकप्रिय ऐक्टिवेशन फ़ंक्शन को रेक्टिफ़ाइड लीनियर यूनिट के लिए RELU कहा जाता है. यह बहुत आसान फ़ंक्शन है, जैसा कि ऊपर दिए गए ग्राफ़ में देखा जा सकता है.
सॉफ़्टमैक्स ऐक्टिवेशन
ऊपर दिया गया नेटवर्क, पांच न्यूरॉन लेयर पर खत्म होता है, क्योंकि हम फूलों को पांच कैटगरी (गुलाब, ट्यूलिप, डैंडेलियन, डेज़ी, सूरजमुखी) में बांट रहे हैं. इंटरमीडिएट लेयर में न्यूरॉन, क्लासिक RELU ऐक्टिवेशन फ़ंक्शन का इस्तेमाल करके चालू किए जाते हैं. हालांकि, आखिरी लेयर में, हमें 0 से 1 के बीच की संख्याएं कैलकुलेट करनी हैं. इनसे यह पता चलता है कि यह फूल गुलाब, ट्यूलिप वगैरह है या नहीं. इसके लिए, हम "softmax" नाम के ऐक्टिवेशन फ़ंक्शन का इस्तेमाल करेंगे.
किसी वेक्टर पर सॉफ़्टमैक्स को लागू करने के लिए, हर एलिमेंट का एक्सपोनेन्शियल निकालें और फिर वेक्टर को नॉर्मलाइज़ किया जाता है. ऐसा आम तौर पर, L1 नॉर्म (निरपेक्ष मानों का योग) का इस्तेमाल करके किया जाता है, ताकि मानों को जोड़ा जा सके और 1 हो और उन्हें प्रायिकता के रूप में समझा जा सके.
क्रॉस-एन्ट्रापी लॉस
अब हमारा न्यूरल नेटवर्क, इनपुट इमेज से अनुमान लगाता है.इसलिए, हमें यह मेज़र करना होगा कि ये अनुमान कितने सही हैं. इसका मतलब है कि नेटवर्क के बताए गए अनुमान और सही जवाबों के बीच की दूरी, जिसे अक्सर "लेबल" कहा जाता है. याद रखें कि हमारे पास डेटासेट में मौजूद सभी इमेज के लिए सही लेबल हैं.
कोई भी डिस्टेंस काम करेगी, लेकिन कैटगरी तय करने से जुड़ी समस्याओं के लिए, "क्रॉस-एन्ट्रोपी डिस्टेंस" सबसे असरदार है. हम इसे गड़बड़ी या "नुकसान" फ़ंक्शन कहेंगे:
ग्रेडिएंट डिसेंट
असल में, न्यूरल नेटवर्क को "ट्रेनिंग" देने का मतलब ट्रेनिंग इमेज और लेबल का इस्तेमाल करके, वज़न और पक्षपात को अडजस्ट करना है, ताकि क्रॉस-एंट्रॉपी लॉस फ़ंक्शन को कम किया जा सके. यह सुविधा इस तरह से काम करती है.
क्रॉस-एंट्रॉपी में वज़न, पक्षपात, ट्रेनिंग इमेज के पिक्सल, और उसकी क्लास की जानकारी होती है.
अगर हम सभी वेट और सभी पूर्वाग्रहों के सापेक्ष क्रॉस-एंट्रॉपी के आंशिक डेरिवेटिव का हिसाब लगाते हैं, तो हमें दी गई इमेज, लेबल, और भार और पक्षपात के मौजूदा मान के लिए एक "ग्रेडिएंट" मिलता है. याद रखें कि हमारे पास लाखों वज़न और पूर्वाग्रह हो सकते हैं, इसलिए ग्रेडिएंट की गणना करना बहुत बड़ा काम है. अच्छी बात यह है कि Tensorflow यह काम हमारे लिए करता है. ग्रेडिएंट की गणितीय विशेषता यह है कि यह "ऊपर" को पॉइंट करता है. चूंकि हम वहां जाना चाहते हैं जहां क्रॉस-एंट्रॉपी कम है, इसलिए हम इसके विपरीत दिशा में जाते हैं. हम ग्रेडिएंट के एक अंश के अनुसार वज़न और पूर्वाग्रह अपडेट करते हैं. इसके बाद, हम ट्रेनिंग लूप में, ट्रेनिंग की इमेज और लेबल के अगले बैच का इस्तेमाल करके, इस काम को बार-बार करते हैं. उम्मीद है कि यह उस जगह पर पहुंच जाएगा जहां क्रॉस-एन्ट्रापी कम से कम होगी. हालांकि, इस बात की कोई गारंटी नहीं है कि यह कम से कम वैल्यू यूनीक होगी.
मिनी बैचिंग और मोमेंटम
सिर्फ़ एक उदाहरण वाली इमेज पर ग्रेडिएंट का हिसाब लगाया जा सकता है और वेट और बायस को तुरंत अपडेट किया जा सकता है. हालांकि, उदाहरण के लिए, 128 इमेज के बैच पर ऐसा करने से, एक ऐसा ग्रेडिएंट मिलता है जो अलग-अलग उदाहरण वाली इमेज से लगाई गई पाबंदियों को बेहतर तरीके से दिखाता है. इसलिए, समाधान पर तेज़ी से पहुंचने की संभावना बढ़ जाती है. मिनी-बैच के साइज़ में बदलाव किया जा सकता है.
इस तकनीक को "स्टोकेस्टिक ग्रेडिएंट डिसेंट" भी कहा जाता है. इसका एक और व्यावहारिक फ़ायदा है: बैच के साथ काम करने का मतलब है बड़े मैट्रिक्स के साथ काम करना. आम तौर पर, जीपीयू और टीपीयू पर इन्हें ऑप्टिमाइज़ करना आसान होता है.
हालांकि, कन्वर्ज़न अब भी थोड़ा गड़बड़ा हो सकता है और अगर ग्रेडिएंट वेक्टर में सभी वैल्यू शून्य हैं, तो यह रुक भी सकता है. क्या इसका मतलब है कि हमें कम से कम वैल्यू मिल गई है? हमेशा नहीं. ग्रेडिएंट कॉम्पोनेंट, कम से कम या ज़्यादा से ज़्यादा वैल्यू पर शून्य हो सकता है. लाखों तत्वों वाले ग्रेडिएंट वेक्टर के साथ, अगर वे सभी शून्य हैं, तो इस बात की संभावना है कि हर शून्य एक न्यूनतम बिंदु से मेल खाता है और उनमें से कोई भी अधिकतम बिंदु से नहीं जुड़ा है. कई डाइमेंशन के क्षेत्र में, सैडल पॉइंट काफ़ी आम हो गए हैं और हम इन पर ही नहीं रुकना चाहते.
इलस्ट्रेशन: सैडल पॉइंट. ग्रेडिएंट 0 है लेकिन यह सभी दिशाओं में कम से कम नहीं है. (इमेज एट्रिब्यूशन Wikimedia: by Nicoguro - खुद का काम, CC BY 3.0)
इसका समाधान है कि ऑप्टिमाइज़ेशन एल्गोरिदम में कुछ चीज़ें जोड़ी जाएं, ताकि यह बिना किसी रुकावट के सैडल पॉइंट से आगे बढ़ सके.
शब्दावली
बैच या मिनी-बैच: ट्रेनिंग हमेशा ट्रेनिंग डेटा और लेबल के बैच पर की जाती है. ऐसा करने से एल्गोरिदम को एक जैसी चीज़ों के बारे में जानने में मदद मिलती है. आम तौर पर, "बैच" डाइमेंशन, डेटा टेंसर का पहला डाइमेंशन होता है. उदाहरण के लिए, आकार के टेंसर [100, 192, 192, 3] में 192x192 पिक्सल की 100 इमेज होती हैं, जिनमें हर पिक्सल (RGB) में तीन वैल्यू होती हैं.
क्रॉस-एन्ट्रोपी लॉस: यह एक खास लॉस फ़ंक्शन है, जिसका इस्तेमाल अक्सर क्लासिफ़ायर में किया जाता है.
गहन लेयर: न्यूरॉन की एक लेयर, जहां हर न्यूरॉन, पिछली लेयर में मौजूद सभी न्यूरॉन से जुड़ा होता है.
features: न्यूरल नेटवर्क के इनपुट को कभी-कभी "सुविधाएं" कहा जाता है. "फ़ीचर इंजीनियरिंग", यह पता लगाने की कला को "फ़ीचर इंजीनियरिंग" कहा जाता है. इसकी मदद से यह पता लगाया जा सकता है कि बेहतर अनुमान पाने के लिए, न्यूरल नेटवर्क में डेटासेट के किन हिस्सों या हिस्सों के कॉम्बिनेशन को फ़ीड किया जाए.
लेबल: सुपरवाइज़्ड क्लासिफ़िकेशन की समस्या में, "क्लास" या सही जवाबों का दूसरा नाम
लर्निंग रेट: ग्रेडिएंट का वह हिस्सा जिसके हिसाब से ट्रेनिंग लूप में हर बार वेट और बायस को अपडेट किया जाता है.
लॉगिट: ऐक्टिवेशन फ़ंक्शन लागू करने से पहले, न्यूरॉन की लेयर के आउटपुट को "लॉगिट" कहा जाता है. यह शब्द, "लॉजिस्टिक फ़ंक्शन" से लिया गया है. इसे "सिगमोइड फ़ंक्शन" भी कहा जाता है. यह सबसे लोकप्रिय ऐक्टिवेशन फ़ंक्शन था. "लॉजिस्टिक फ़ंक्शन से पहले न्यूरॉन आउटपुट" को छोटा करके "लॉगिट" कर दिया गया.
loss: गड़बड़ी का फ़ंक्शन, जो सही जवाबों के साथ न्यूरल नेटवर्क के आउटपुट की तुलना करता है
न्यूरॉन: अपने इनपुट का वेटेड योग कैलकुलेट करता है, एक पूर्वाग्रह जोड़ता है, और नतीजे को ऐक्टिवेशन फ़ंक्शन के ज़रिए फ़ीड करता है.
वन-हॉट एन्कोडिंग: पांच में से तीसरी क्लास को पांच एलिमेंट के वेक्टर के तौर पर एन्कोड किया जाता है. इसमें तीसरे एलिमेंट को छोड़कर सभी एलिमेंट शून्य होते हैं.
relu: सुधारी गई लीनियर यूनिट. न्यूरॉन के लिए एक लोकप्रिय ऐक्टिवेशन फ़ंक्शन.
सिगमॉइड: यह एक और ऐक्टिवेशन फ़ंक्शन है, जो पहले काफ़ी लोकप्रिय था और अब भी खास मामलों में काम आता है.
सॉफ़्टमैक्स: यह एक खास ऐक्टिवेशन फ़ंक्शन है, जो वेक्टर पर काम करता है. यह सबसे बड़े कॉम्पोनेंट और बाकी सभी के बीच के अंतर को बढ़ाता है. साथ ही, वेक्टर को 1 का योग करने के लिए नॉर्मलाइज़ करता है, ताकि इसे प्रॉबबिलिटी के वेक्टर के रूप में समझा जा सके. इसका इस्तेमाल, क्लासिफ़ायर में आखिरी चरण के तौर पर किया जाता है.
टेंसर: "टेंसर", मैट्रिक्स की तरह ही होता है. हालांकि, इसमें डाइमेंशन की संख्या ज़रूरी नहीं होती. एक डाइमेंशन वाला टेंसर, एक वेक्टर होता है. दो डाइमेंशन वाला टेंसर एक मैट्रिक्स होता है. इसके बाद, आपके पास 3, 4, 5 या उससे ज़्यादा डाइमेंशन वाले टेंसर हो सकते हैं.
5. [INFO] कॉन्वोलूशनल न्यूरल नेटवर्क
कम शब्दों में
अगर अगले पैराग्राफ़ में बोल्ड में दिए गए सभी शब्दों के बारे में आपको पहले से पता है, तो अगले अभ्यास पर जाएं. अगर आपने अभी-अभी कॉन्वोल्यूशनल न्यूरल नेटवर्क का इस्तेमाल शुरू किया है, तो कृपया आगे पढ़ें.
इलस्ट्रेशन: किसी इमेज को फ़िल्टर करने के लिए, हर फ़िल्टर का क्रम में 4x4x3=48 वज़न दिया गया है.
Keras में ऐसा सिंपल कॉन्वोलूशन न्यूरल नेटवर्क दिखता है:
model = tf.keras.Sequential([
# input: images of size 192x192x3 pixels (the three stands for RGB channels)
tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
tf.keras.layers.Flatten(),
# classifying into 5 categories
tf.keras.layers.Dense(5, activation='softmax')
])
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy'])
कन्वोल्यूशनल न्यूरल नेट के बारे में बुनियादी जानकारी
कॉन्वलूशनल नेटवर्क की एक लेयर में, एक "न्यूरॉन" इमेज के एक छोटे से क्षेत्र में इसके ठीक ऊपर पिक्सल का वेटेड योग करता है. यह पूर्वाग्रह जोड़ता है और ऐक्टिवेशन फ़ंक्शन के ज़रिए योग को फ़ीड करता है, जैसा कि किसी नियमित सघन परत में मौजूद न्यूरॉन करता है. इसके बाद, इसी वेट का इस्तेमाल करके पूरी इमेज में यह प्रोसेस दोहराई जाती है. याद रखें कि घनी लेयर में, हर न्यूरॉन का अपना वेट होता है. यहां, वेट का एक "पैच", इमेज पर दोनों दिशाओं में स्लाइड करता है (एक "कंवोल्यूशन"). आउटपुट में उतनी वैल्यू होती हैं जितनी इमेज में पिक्सल होती हैं. हालांकि, किनारों पर कुछ पैडिंग (जगह) ज़रूरी है. यह 4x4x3=48 मोटाई वाले फ़िल्टर का इस्तेमाल करके, फ़िल्टर करने की एक कार्रवाई होती है.
हालांकि, 48 वेट काफ़ी नहीं होंगे. ज़्यादा डिग्री ऑफ़ फ़्रीडम जोड़ने के लिए, हम वेट के नए सेट के साथ वही ऑपरेशन दोहराते हैं. इससे, फ़िल्टर आउटपुट का एक नया सेट बनता है. इनपुट इमेज में R,G,B चैनलों की तरह ही, इसे आउटपुट का "चैनल" कहें.
नया डाइमेंशन जोड़कर, वेट के दो (या उससे ज़्यादा) सेट को एक टेंसर के तौर पर जोड़ा जा सकता है. इससे हमें कॉन्वलूशन लेयर के लिए, वेट टेंसर का सामान्य आकार मिलता है. इनपुट और आउटपुट चैनल की संख्या पैरामीटर हैं. इसलिए, हम कॉन्वोलूशनल लेयर को स्टैक और चेन करना शुरू कर सकते हैं.
इलस्ट्रेशन: कॉन्वलूशनल न्यूरल नेटवर्क, डेटा के "क्यूब्स" को डेटा के अन्य "क्यूब्स" में बदलता है.
स्टैंडेड कॉन्वोलूशन, ज़्यादा से ज़्यादा पूल करना
दो या तीन की स्ट्राइड के साथ कॉन्वोल्यूशन करने पर, हम नतीजे वाले डेटा क्यूब को उसके हॉरिज़ॉन्टल डाइमेंशन में भी छोटा कर सकते हैं. ऐसा करने के दो सामान्य तरीके हैं:
- स्ट्राइड वाला कन्वोल्यूशन: ऊपर बताए गए स्लाइडिंग फ़िल्टर की तरह ही, लेकिन स्ट्राइड >1 के साथ
- अधिकतम पूलिंग: MAX ऑपरेशन लागू करने वाली स्लाइड करने वाली विंडो (आम तौर पर 2x2 पैच पर, हर 2 पिक्सेल में दोहराया जाता है)
इलस्ट्रेशन: कंप्यूटिंग विंडो को तीन पिक्सल स्लाइड करने से आउटपुट वैल्यू कम हो जाती है. स्ट्राइड कन्वोल्यूशन या मैक्स पूलिंग (2x2 विंडो पर मैक्स, जो दो की स्ट्राइड से स्लाइड करती है), हॉरिज़ॉन्टल डाइमेंशन में डेटा क्यूब को छोटा करने का एक तरीका है.
Convolutional classifier
आखिर में, हम आखिरी डेटा क्यूब को फ़्लैट करके, उसे सॉफ़्टमैक्स चालू की गई लेयर में फ़ीड करके, क्लासिफ़िकेशन हेड अटैच करते हैं. एक सामान्य कॉन्वोलूशनल क्लासिफ़ायर ऐसा दिख सकता है:
इलस्ट्रेशन: इमेज की कैटगरी तय करने वाला एल्गोरिदम, जिसमें कन्वर्ज़न और सॉफ़्टमैक्स लेयर का इस्तेमाल किया गया है. इसमें 3x3 और 1x1 फ़िल्टर का इस्तेमाल किया जाता है. मैक्सपूल लेयर, 2x2 डेटा पॉइंट के ग्रुप में से सबसे ज़्यादा डेटा पॉइंट लेती हैं. क्लासिफ़िकेशन हेड को सॉफ़्टमैक्स ऐक्टिवेशन के साथ एक सघन लेयर के साथ लागू किया जाता है.
Keras में
ऊपर दिखाए गए कॉन्वोलूशनल स्टैक को Keras में इस तरह लिखा जा सकता है:
model = tf.keras.Sequential([
# input: images of size 192x192x3 pixels (the three stands for RGB channels)
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
tf.keras.layers.Flatten(),
# classifying into 5 categories
tf.keras.layers.Dense(5, activation='softmax')
])
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy'])
6. [नई जानकारी] आधुनिक कॉन्वोल्यूशनल आर्किटेक्चर
कम शब्दों में
इलस्ट्रेशन: एक कॉन्वोल्यूशनल "मॉड्यूल". इस समय क्या करना सबसे सही होगा ? मैक्स-पूल लेयर के बाद 1x1 कॉन्वोल्यूशनल लेयर या लेयर का कोई दूसरा कॉम्बिनेशन ? सभी को आज़माएं, नतीजों को जोड़ें, और नेटवर्क को तय करने दें. दाईं ओर: ऐसे मॉड्यूल का इस्तेमाल करने वाला " inception" कॉन्वोल्यूशनल आर्किटेक्चर.
Keras में, ऐसे मॉडल बनाने के लिए जिनमें डेटा फ़्लो, दो हिस्सों में बंटे हो सकता है, आपको "फ़ंक्शनल" मॉडल स्टाइल का इस्तेमाल करना होगा. उदाहरण के लिए:
l = tf.keras.layers # syntax shortcut
y = l.Conv2D(filters=32, kernel_size=3, padding='same',
activation='relu', input_shape=[192, 192, 3])(x) # x=input image
# module start: branch out
y1 = l.Conv2D(filters=32, kernel_size=1, padding='same', activation='relu')(y)
y3 = l.Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')(y)
y = l.concatenate([y1, y3]) # output now has 64 channels
# module end: concatenation
# many more layers ...
# Create the model by specifying the input and output tensors.
# Keras layers track their connections automatically so that's all that's needed.
z = l.Dense(5, activation='softmax')(y)
model = tf.keras.Model(x, z)
कम कीमत पर मिलने वाली अन्य तरकीबें
3x3 साइज़ के छोटे फ़िल्टर
इस इलस्ट्रेशन में, आपको लगातार दो 3x3 फ़िल्टर का नतीजा दिख रहा है. यह पता लगाने की कोशिश करें कि नतीजे में किन डेटा पॉइंट का योगदान रहा: लगातार दो 3x3 फ़िल्टर, 5x5 क्षेत्र के कुछ कॉम्बिनेशन का हिसाब लगाते हैं. यह वैसा ही कॉम्बिनेशन नहीं है जैसा 5x5 फ़िल्टर कैलकुलेट करेगा, लेकिन इसे आज़माने की ज़रूरत है. इसकी वजह यह है कि एक 5x5 फ़िल्टर की तुलना में, लगातार दो 3x3 फ़िल्टर सस्ते होते हैं.
1x1 कन्वर्ज़न ?
गणित के हिसाब से, "1x1" कॉन्वोल्यूशन, किसी स्थिर वैल्यू से गुणा करने जैसा है. यह बहुत काम का कॉन्सेप्ट नहीं है. हालांकि, कॉन्वलूशनल न्यूरल नेटवर्क में यह याद रखें कि फ़िल्टर, सिर्फ़ 2D इमेज पर ही नहीं, बल्कि डेटा क्यूब पर लागू किया जाता है. इसलिए, "1x1" फ़िल्टर, डेटा के 1x1 कॉलम का वेटेड योग (इमेज देखें) कैलकुलेट करता है. साथ ही, डेटा पर इसे स्लाइड करने पर, आपको इनपुट के चैनलों का लीनियर कॉम्बिनेशन मिलेगा. यह असल में काम का है. अगर चैनलों को अलग-अलग फ़िल्टर करने के ऑपरेशन के नतीजों के तौर पर देखा जाए, तो "1x1" कॉन्वोल्यूशनल लेयर इन फ़ीचर के कई संभावित लीनियर कॉम्बिनेशन कैलकुलेट करेगी. ये "बिल्ली" खोजते समय काम आ सकते हैं. उदाहरण के लिए, "नुकीले कान", "मूंछ", और "छोटी आंखें" के लिए फ़िल्टर. इसके अलावा, 1x1 लेयर कम वेट का इस्तेमाल करती हैं.
7. स्क्वीज़नेट
इन आइडिया को एक साथ इस्तेमाल करने का आसान तरीका, "Squeezenet" पेपर में दिखाया गया है. लेखकों ने एक बहुत ही आसान कॉन्वोल्यूशनल मॉड्यूल डिज़ाइन का सुझाव दिया है. इसमें सिर्फ़ 1x1 और 3x3 कॉन्वोल्यूशनल लेयर का इस्तेमाल किया गया है.
इलस्ट्रेशन: "फ़ायर मॉड्यूल" पर आधारित स्क्वीज़नेट आर्किटेक्चर. वे एक 1x1 लेयर के विकल्प का इस्तेमाल करते हैं, जो वर्टिकल डाइमेंशन में आने वाले डेटा को "निचोड़" करती है. इसके बाद, दो पैरलल 1x1 और 3x3 कॉन्वलूशनल लेयर होती हैं जो डेटा को फिर से "बड़ा" करती हैं.
हैंड्स-ऑन
अपनी पिछली नोटबुक में जारी रखें और स्क्वीज़नेट से प्रेरित कॉन्वलूशनल न्यूरल नेटवर्क बनाएं. आपको मॉडल कोड को Keras "फ़ंक्शनल स्टाइल" में बदलना होगा.
Keras_Flowers_TPU (playground).ipynb
ज़्यादा जानकारी
इस एक्सरसाइज़ से स्क्वीज़नेट मॉड्यूल के लिए हेल्पर फ़ंक्शन तय करने में मदद मिलेगी:
def fire(x, squeeze, expand):
y = l.Conv2D(filters=squeeze, kernel_size=1, padding='same', activation='relu')(x)
y1 = l.Conv2D(filters=expand//2, kernel_size=1, padding='same', activation='relu')(y)
y3 = l.Conv2D(filters=expand//2, kernel_size=3, padding='same', activation='relu')(y)
return tf.keras.layers.concatenate([y1, y3])
# this is to make it behave similarly to other Keras layers
def fire_module(squeeze, expand):
return lambda x: fire(x, squeeze, expand)
# usage:
x = l.Input(shape=[192, 192, 3])
y = fire_module(squeeze=24, expand=48)(x) # typically, squeeze is less than expand
y = fire_module(squeeze=32, expand=64)(y)
...
model = tf.keras.Model(x, y)
इस बार हमारा मकसद 80% सटीक अनुमान देना है.
ये काम आज़माएं
एक कॉन्वोलूशन लेयर से शुरू करें, फिर MaxPooling2D(pool_size=2) लेयर के साथ बदलते हुए "fire_modules" के साथ फ़ॉलो करें. नेटवर्क में दो से चार मैक्स पूलिंग लेयर का इस्तेमाल किया जा सकता है. साथ ही, मैक्स पूलिंग लेयर के बीच एक, दो या तीन फ़ायर मॉड्यूल का भी इस्तेमाल किया जा सकता है.
फ़ायर मॉड्यूल में, "स्क्वीज़" पैरामीटर आम तौर पर "expand" पैरामीटर से छोटा होना चाहिए. ये पैरामीटर, असल में फ़िल्टर की संख्याएं होती हैं. आम तौर पर, इनकी संख्या 8 से 196 तक हो सकती है. ऐसे आर्किटेक्चर आज़माए जा सकते हैं जिनमें नेटवर्क के ज़रिए फ़िल्टर की संख्या धीरे-धीरे बढ़ती है. इसके अलावा, ऐसे आसान आर्किटेक्चर भी आज़माए जा सकते हैं जिनमें सभी फ़ायर मॉड्यूल में फ़िल्टर की संख्या एक जैसी होती है.
उदाहरण के लिए:
x = tf.keras.layers.Input(shape=[*IMAGE_SIZE, 3]) # input is 192x192 pixels RGB
y = tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu')(x)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.GlobalAveragePooling2D()(y)
y = tf.keras.layers.Dense(5, activation='softmax')(y)
model = tf.keras.Model(x, y)
इस स्थिति में, आपको लग सकता है कि आपके एक्सपेरिमेंट ठीक से काम नहीं कर रहे हैं. साथ ही, 80% सटीक नतीजे पाने का मकसद आपको रिमोट तरीके से दिख रहा है. कुछ और आसान तरकीबें आज़माने का समय आ गया है.
बैच नॉर्मलाइज़ेशन
बैच नॉर्म की मदद से, आपको कन्वर्ज़न से जुड़ी समस्याओं को हल करने में मदद मिलेगी. आपको अगली वर्कशॉप में, इस तकनीक के बारे में पूरी जानकारी दी जाएगी. फ़िलहाल, कृपया इसे ब्लैक बॉक्स "मैजिक" हेल्पर के तौर पर इस्तेमाल करें. इसके लिए, अपने नेटवर्क में हर कॉन्वोल्यूशन लेयर के बाद यह लाइन जोड़ें. इसमें, Fire_module फ़ंक्शन के अंदर की लेयर भी शामिल हैं:
y = tf.keras.layers.BatchNormalization(momentum=0.9)(y)
# please adapt the input and output "y"s to whatever is appropriate in your context
हमारा डेटासेट छोटा होने की वजह से, मोमेंटम पैरामीटर की डिफ़ॉल्ट वैल्यू 0.99 से घटाकर 0.9 करनी होगी. फ़िलहाल, इस जानकारी को न दें.
डेटा बढ़ाना
डेटा को आसान ट्रांसफ़ॉर्मेशन की मदद से बेहतर बनाने पर, आपको कुछ और प्रतिशत पॉइंट मिलेंगे. जैसे, सैचुरेशन में बदलाव करके, बाईं ओर से दाईं ओर फ़्लिप करना:
tf.data.Dataset एपीआई की मदद से, Tensorflow में ऐसा करना काफ़ी आसान है. अपने डेटा के लिए, ट्रांसफ़ॉर्मेशन का नया फ़ंक्शन तय करें:
def data_augment(image, label):
image = tf.image.random_flip_left_right(image)
image = tf.image.random_saturation(image, lower=0, upper=2)
return image, label
इसके बाद, इसे अपने आखिरी डेटा ट्रांसफ़ॉर्मेशन (सेल "ट्रेनिंग और पुष्टि करने वाले डेटासेट", फ़ंक्शन "get_batched_dataset") में इस्तेमाल करें:
dataset = dataset.repeat() # existing line
# insert this
if augment_data:
dataset = dataset.map(data_augment, num_parallel_calls=AUTO)
dataset = dataset.shuffle(2048) # existing line
डेटा बढ़ाने की सुविधा को वैकल्पिक बनाना न भूलें. साथ ही, ज़रूरी कोड जोड़कर यह पक्का करें कि सिर्फ़ ट्रेनिंग डेटासेट को बढ़ाया गया हो. पुष्टि करने के लिए ज़्यादा डेटासेट का इस्तेमाल करने का कोई मतलब नहीं है.
35 युगों में 80% सटीक जानकारी अब पहुंच में होनी चाहिए.
समाधान
यहां समाधान वाली नोटबुक दी गई है. अगर आपको कोई समस्या आ रही है, तो इसका इस्तेमाल किया जा सकता है.
Keras_Flowers_TPU_squeezenet.ipynb
हमने क्या-क्या शामिल किया है
- 🤔 Keras "फ़ंक्शनल स्टाइल" मॉडल
- 🤓 Squeezenet आर्किटेक्चर
- 🤓 tf.data.datset की मदद से डेटा बढ़ाना
कृपया कुछ समय निकालकर इस चेकलिस्ट को देखें.
8. Xception को फ़ाइन-ट्यून किया गया
अलग-अलग कॉन्वोल्यूशन
हाल ही में, कॉन्वोल्यूशनल लेयर लागू करने का एक अलग तरीका लोकप्रिय हो रहा है: डेप्थ-सेपरेबल कॉन्वोल्यूशन. मुझे पता है कि यह समझने में मुश्किल है, लेकिन इसका कॉन्सेप्ट बहुत आसान है. इन्हें Tensorflow और Keras में tf.keras.layers.SeparableConv2D के तौर पर लागू किया जाता है.
अलग किया जा सकने वाला कन्वर्ज़न, इमेज पर भी एक फ़िल्टर चलाता है. हालांकि, यह इनपुट इमेज के हर चैनल के लिए, वेट के एक अलग सेट का इस्तेमाल करता है. इसके बाद, "1x1 कन्वोल्यूशन" होता है. यह डॉट प्रॉडक्ट की एक सीरीज़ होती है, जिससे फ़िल्टर किए गए चैनलों का वेटेड योग मिलता है. हर बार नए वेट के साथ, चैनल के वेटेड रीकॉम्बिनेशन को ज़रूरत के मुताबिक कैलकुलेट किया जाता है.
इलस्ट्रेशन: अलग-अलग कॉन्वोल्यूशन. पहला चरण: हर चैनल के लिए अलग फ़िल्टर के साथ कॉन्वोल्यूशन. दूसरा चरण: चैनलों का लीनियर रीकॉम्बिनेशन. आउटपुट चैनलों की मनचाहे संख्या तक पहुंचने तक, वेट के एक नए सेट के साथ दोहराया जाता है. पहले चरण को दोहराया भी जा सकता है. हालांकि, ऐसा हर बार नए वेट के साथ नहीं किया जाता.
अलग-अलग कॉन्वोल्यूशन का इस्तेमाल, हाल ही के कॉन्वोल्यूशनल नेटवर्क आर्किटेक्चर में किया जाता है: MobileNetV2, Xception, EfficientNet. वैसे, MobileNetV2 का इस्तेमाल पहले ट्रांसफ़र लर्निंग के लिए किया गया था.
ये सामान्य कॉन्वोल्यूशन की तुलना में सस्ते होते हैं और इनकी परफ़ॉर्मेंस भी उतनी ही अच्छी होती है. ऊपर दिए गए उदाहरण के लिए, यहां वेट की संख्या दी गई है:
कॉन्वोल्यूशनल लेयर: 4 x 4 x 3 x 5 = 240
अलग-अलग कॉन्वोल्यूशनल लेयर: 4 x 4 x 3 + 3 x 5 = 48 + 15 = 63
इसे पढ़ने वालों के लिए एक अभ्यास के तौर पर इस्तेमाल किया जाता है. इसमें, कॉन्वोलूशनल लेयर स्केल की हर स्टाइल को एक ही तरीके से लागू करने के लिए, मल्टीप्लिकेशन की संख्या के मुकाबले इसका कैलकुलेशन करना ज़रूरी है. अलग किए जा सकने वाले कन्वर्ज़न छोटे होते हैं और कंप्यूटेशनल तौर पर ज़्यादा असरदार होते हैं.
हैंड्स-ऑन
"ट्रांसफ़र लर्निंग" प्लेग्राउंड नोटबुक से रीस्टार्ट करें. हालांकि, इस बार Xception को पहले से ट्रेन किए गए मॉडल के तौर पर चुनें. Xception में सिर्फ़ अलग-अलग कॉन्वोल्यूशन का इस्तेमाल किया जाता है. सभी वेट को ट्रेनिंग के लिए उपलब्ध रखें. हम पहले से ट्रेन की गई लेयर का इस्तेमाल करने के बजाय, अपने डेटा पर पहले से ट्रेन किए गए वेट को बेहतर बनाएंगे.
Keras Flowers transfer learning (playground).ipynb
लक्ष्य: सटीक जानकारी > 95% (नहीं, वाकई में ऐसा किया जा सकता है!)
यह आखिरी एक्सरसाइज़ है. इसमें थोड़े और कोड और डेटा साइंस के काम की ज़रूरत है.
बेहतर बनाने के बारे में ज़्यादा जानकारी
Xception, tf.keras.application में पहले से ट्रेनिंग किए गए स्टैंडर्ड मॉडल में उपलब्ध है.* इस बार ट्रेनिंग के लिए सभी वज़न हटाना न भूलें.
pretrained_model = tf.keras.applications.Xception(input_shape=[*IMAGE_SIZE, 3],
include_top=False)
pretrained_model.trainable = True
किसी मॉडल को बेहतर बनाने के दौरान अच्छे नतीजे पाने के लिए, आपको लर्निंग रेट पर ध्यान देना होगा. साथ ही, रैंप-अप पीरियड के साथ लर्निंग रेट के शेड्यूल का इस्तेमाल करना होगा. इस तरह:
अगर स्टैंडर्ड लर्निंग रेट का इस्तेमाल किया जाए, तो मॉडल की ट्रेनिंग वाले वेट पर असर पड़ेगा. शुरू करने से, उन्हें तब तक सुरक्षित रखता है, जब तक मॉडल आपके डेटा पर लैच नहीं हो जाता. यह उनमें सही तरीके से बदलाव करने में मदद करता है. रैंप के बाद, लर्निंग रेट को एक जैसा या तेज़ी से घटते हुए रखा जा सकता है.
Keras में, लर्निंग रेट को कॉलबैक के ज़रिए तय किया जाता है. इसमें हर एपिसोड के लिए सही लर्निंग रेट का हिसाब लगाया जा सकता है. Keras हर epoch के लिए, ऑप्टिमाइज़र को सीखने की सही दर पास करेगा.
def lr_fn(epoch):
lr = ...
return lr
lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_fn, verbose=True)
model.fit(..., callbacks=[lr_callback])
समाधान
यहां समाधान वाली नोटबुक दी गई है. अगर आपको कोई समस्या आ रही है, तो इसका इस्तेमाल किया जा सकता है.
07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb
इसमें हमने इन विषयों के बारे में बताया
- 🤔 गहराई से अलग किया जा सकने वाला कन्वर्ज़न
- 🤓 सीखने की दर के शेड्यूल
- 🚫 पहले से तैयार मॉडल को बेहतर बनाना.
कृपया कुछ समय निकालकर इस चेकलिस्ट को देखें.
9. बधाई हो!
आपने अपना पहला आधुनिक कॉन्वोलूशनल न्यूरल नेटवर्क बना लिया है और उसे 90% + सटीक बनाने की ट्रेनिंग दी है. TPU की बदौलत आप कुछ ही मिनटों में लगातार ट्रेनिंग कर रहे हैं. इसके बाद, "TPU कोडलैब पर केरस" के चार इवेंट खत्म हुए:
- TPU-स्पीड डेटा पाइपलाइन: tf.data.Dataset और TFRecords
- ट्रांसफ़र लर्निंग की मदद से, अपना पहला Keras मॉडल बनाना
- केरास और टीपीयू के साथ कन्वलूशनल न्यूरल नेटवर्क
- [THIS LAB] Keras और TPU के साथ आधुनिक कॉन्वेंट, स्क्वाइज़नेट, और एक्ससेप्शन
TPU का इस्तेमाल
TPU और जीपीयू, Cloud AI Platform पर उपलब्ध हैं:
- डीप लर्निंग वीएम पर
- AI Platform Notebooks में
- AI Platform Training से जुड़ी नौकरियों में
आखिर में, हमें सुझाव, राय या शिकायत ज़रूर भेजें. अगर आपको इस लैब में कुछ गड़बड़ी दिखती है या आपको लगता है कि इसमें सुधार किया जाना चाहिए, तो कृपया हमें बताएं. GitHub की समस्याओं के ज़रिए, सुझाव या राय दी जा सकती है [ feedback link].
|
