इस पेज का अनुवाद Cloud Translation API से किया गया है.

Keras और TPU के साथ मॉडर्न कन्नेट, स्क्विज़नेट, Xception

1. खास जानकारी

इस लैब में, आपको आधुनिक कॉन्वोलूशनल आर्किटेक्चर के बारे में जानकारी मिलेगी. साथ ही, अपनी जानकारी का इस्तेमाल करके "स्क्वीज़नेट" नाम के आसान, लेकिन असरदार कन्वर्ज़न को लागू करना होगा.

इस लैब में, कॉन्वलूशनल न्यूरल नेटवर्क के बारे में ज़रूरी सैद्धांतिक व्याख्याएं शामिल हैं. साथ ही, डीप लर्निंग के बारे में सीखने वाले डेवलपर के लिए, यह लैब एक अच्छा शुरुआती पॉइंट है.

यह लैब, "TPU पर केरस" का चौथा पार्ट है सीरीज़ शामिल है. नीचे दिए गए क्रम में या अलग से ऐसा किया जा सकता है.

TPU-स्पीड डेटा पाइपलाइन: tf.data.Dataset और TFRecords
ट्रांसफ़र लर्निंग के साथ आपका पहला Keras मॉडल
केरास और टीपीयू के साथ कनवलूशनल न्यूरल नेटवर्क
[THIS LAB] केराज़ और TPU के साथ मॉडर्न कन्वर्ज़न, स्क्विज़नेट, Xception

आप इन चीज़ों के बारे में जानेंगे

Keras की फ़ंक्शनल स्टाइल में महारत हासिल करने के लिए
स्क्विज़नेट आर्किटेक्चर का इस्तेमाल करके मॉडल बनाने के लिए
TPU का इस्तेमाल करके, अपने सिस्टम को तेज़ी से ट्रेनिंग देना और उसे दोहराना
tf.data.dataset की मदद से, डेटा को बेहतर बनाने की सुविधा को लागू करने के लिए
TPU पर पहले से ट्रेन किए गए बड़े मॉडल (Xception) को बेहतर बनाने के लिए

सुझाव, राय या शिकायत

अगर आपको इस कोड लैब में कोई गड़बड़ी दिखती है, तो कृपया हमें बताएं. GitHub की समस्याओं के ज़रिए, सुझाव या राय दी जा सकती है [ feedback link].

2. Google Colaboratory क्विक स्टार्ट

यह लैब, Google Collaboratory का इस्तेमाल करता है और आपको अपनी ओर से किसी सेटअप की ज़रूरत नहीं होती. Colaboratory, शिक्षा के मकसद से बनाया गया एक ऑनलाइन नोटबुक प्लैटफ़ॉर्म है. इसमें सीपीयू, जीपीयू, और TPU की मुफ़्त ट्रेनिंग दी जाती है.

Colaboratory के बारे में जानने के लिए, इस सैंपल नोटबुक को खोला जा सकता है और कुछ सेल को चलाया जा सकता है.

Welcome to Colab.ipynb

कोई TPU बैकएंड चुनें

Colab मेन्यू में, रनटाइम > रनटाइम टाइप बदलें और फिर TPU चुनें. इस कोड लैब में, हार्डवेयर से तेज़ी से की जाने वाली ट्रेनिंग के लिए इस्तेमाल होने वाला दमदार TPU (Tensor प्रोसेसिंग यूनिट) इस्तेमाल किया जा सकता है. पहली बार एक्ज़ीक्यूशन करने पर, रनटाइम से कनेक्शन अपने-आप हो जाएगा. इसके अलावा, आपके पास "कनेक्ट करें" का इस्तेमाल करने का भी विकल्प है बटन पर क्लिक करें.

नोटबुक चलाना

सेल पर क्लिक करके और Shift-ENTER का इस्तेमाल करके एक-एक करके सेल एक्ज़ीक्यूट करें. रनटाइम > सभी को चलाएं

विषय सूची

सभी नोटबुक में विषय सूची होती है. इसे खोलने के लिए, बाईं ओर मौजूद काले रंग के ऐरो का इस्तेमाल करें.

छिपे हुए सेल

कुछ सेल में सिर्फ़ उनका टाइटल दिखेगा. यह notebook की सुविधा है, जो खास तौर पर Colab के लिए बनाई गई है. अंदर का कोड देखने के लिए उन पर दो बार क्लिक करें, लेकिन आम तौर पर यह बहुत दिलचस्प नहीं होता. आम तौर पर, सहायता या विज़ुअलाइज़ेशन फ़ंक्शन. अंदर के फ़ंक्शन को परिभाषित करने के लिए, आपको अब भी इन सेल को चलाना होगा.

पुष्टि करना

Colab, Google Cloud Storage की आपकी निजी बकेट को ऐक्सेस कर सकता है. इसके लिए, ज़रूरी है कि आपने अनुमति वाले किसी खाते से पुष्टि की हो. ऊपर दिया गया कोड स्निपेट, पुष्टि करने की प्रोसेस को ट्रिगर करेगा.

3. [INFO] टेन्सर प्रोसेसिंग यूनिट (टीपीयू) क्या हैं ?

कम शब्दों में

TPU, हार्डवेयर ऐक्सेलरेटर हैं. इन्हें डीप लर्निंग के टास्क में इस्तेमाल करने में महारत हासिल है. इस कोड लैब में, आपको Keras और Tensorflow 2 के साथ इनका इस्तेमाल करने का तरीका बताया जाएगा. Cloud TPU, 8 कोर वाले बेस कॉन्फ़िगरेशन में उपलब्ध हैं. साथ ही, ये "TPU पॉड" नाम के बड़े कॉन्फ़िगरेशन में भी उपलब्ध हैं 2048 कोर तक हो सकता है. इसमें ट्रेनिंग बैच का साइज़ बढ़ाकर, ट्रेनिंग में तेज़ी लाने के लिए अतिरिक्त हार्डवेयर का इस्तेमाल किया जा सकता है.

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 रेंडरिंग, डीप लर्निंग, फ़िज़िकल सिम्युलेशन वगैरह जैसे कई काम कर सकते हैं. वहीं दूसरी ओर TPU, क्लासिक वेक्टर प्रोसेसर को खास मैट्रिक्स गुणा वाली यूनिट के साथ जोड़ता है. इससे ऐसे किसी भी टास्क को बेहतर किया जा सकता है जिसमें बड़े मैट्रिक्स गुणन की मुख्य स्थिति हो, जैसे कि न्यूरल नेटवर्क.

इलस्ट्रेशन: मैट्रिक्स मल्टीप्लिकेशन के तौर पर सघन न्यूरल नेटवर्क लेयर. इसमें न्यूरल नेटवर्क से एक साथ प्रोसेस की गई आठ इमेज का बैच है. कृपया एक लाइन x कॉलम को गुणा करें और देखें कि यह असल में किसी इमेज की सभी पिक्सल वैल्यू का वेटेड योग कर रहा है या नहीं. कनवॉल्यूशन लेयर को मैट्रिक्स गुणा के तौर पर भी दिखाया जा सकता है. हालांकि, यह थोड़ा जटिल है ( एक्सप्लेनेशन यहां, सेक्शन 1 में बताया गया है).

हार्डवेयर

MXU और VPU

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 आउटपुट. इसका मतलब है कि आम तौर पर, कम सटीक परफ़ॉर्मेंस का फ़ायदा पाने के लिए, कोड में किसी तरह के बदलाव की ज़रूरत नहीं होती.

bfloat16/float32 मिले-जुले सटीक तरीके का इस्तेमाल, TPU पर डिफ़ॉल्ट रूप से लागू होता है. इसे चालू करने के लिए, आपके Tensorflow कोड में किसी कोड में बदलाव करने की ज़रूरत नहीं है. आप अपने पूरे कोड में अब भी 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 "कोर" की ज़रूरत होगी उपलब्ध होना चाहिए, जो आम तौर पर मुमकिन नहीं होता. सबसे बड़े जीपीयू में करीब 4000 कोर होते हैं. वहीं दूसरी ओर, TPU, MXU में कंप्यूट यूनिट के लिए कम से कम हार्डवेयर का इस्तेमाल करता है. इसमें सिर्फ़ bfloat16 x bfloat16 => float32 मल्टी-अक्युमिलेटर हैं, कुछ और नहीं. ये तरीके इतने छोटे होते हैं कि TPU इनमें से 16K कोड को 128x128 MXU में इस्तेमाल कर सकता है. साथ ही, इस मैट्रिक्स गुणा को एक ही बार में प्रोसेस कर सकता है.

इलस्ट्रेशन: MXU सिस्टोलिक अरे. कंप्यूट एलिमेंट, मल्टी-अक्युमिलेटर होते हैं. एक मैट्रिक्स की वैल्यू अरे (लाल बिंदु) में लोड होती हैं. अन्य मैट्रिक्स की वैल्यू, कलेक्शन (स्लेटी बिंदु) से होकर गुज़रती हैं. वर्टिकल लाइनें, वैल्यू को ऊपर की ओर ले जाती हैं. हॉरिज़ॉन्टल लाइनें, आंशिक योग को लागू करती हैं. इसे उपयोगकर्ता को कसरत के तौर पर छोड़ दिया जाता है, ताकि यह पुष्टि की जा सके कि जैसे-जैसे डेटा अरे से गुज़रेगा वैसे-वैसे आपको दाईं ओर से मिले मैट्रिक्स गुणा का नतीजा मिलेगा.

इसके अलावा, जहां बिंदु प्रॉडक्ट का हिसाब MXU में लगाया जाता है, वहीं इंटरमीडिएट योग आस-पास की कंप्यूट यूनिटों के बीच ट्रांसफ़र होते हैं. उन्हें मेमोरी या रजिस्टर फ़ाइल में भी स्टोर करने या वापस लाने की ज़रूरत नहीं होती. आखिरी नतीजा यह है कि TPU सिस्टोलिक अरे आर्किटेक्चर को बहुत ज़्यादा सघनता और पावर का फ़ायदा मिलता है. साथ ही, मैट्रिक्स गुणन की गणना करते समय जीपीयू पर गति का अच्छा-सा फ़ायदा मिलता है.

क्लाउड टीपीयू

जब आप किसी " Cloud TPU v2" Google Cloud Platform पर, आपको एक वर्चुअल मशीन (वीएम) मिलती है. इसमें पीसीआई से अटैच किया गया TPU बोर्ड होता है. TPU बोर्ड में, ड्यूअल-कोर TPU चिप होते हैं. हर TPU कोर में एक VPU (वेक्टर प्रोसेसिंग यूनिट) और 128x128 MXU (मैट्रिक्स गुणा यूनिट) मौजूद होता है. यह "Cloud TPU" इसके बाद, नेटवर्क के ज़रिए उस वीएम से कनेक्ट होता है जिसने इसके लिए अनुरोध किया था. पूरी जानकारी कुछ इस तरह दिखती है:

इलस्ट्रेशन: नेटवर्क से जुड़े "Cloud TPU" के साथ आपकी वीएम एक्सेलरेटर. "क्लाउड टीपीयू" यह वर्चुअल मशीन (वीएम) से बनी है. इसमें पीसीआई से जुड़ा TPU बोर्ड होता है. इस पर चार ड्यूअल-कोर TPU चिप मौजूद होते हैं.

TPU पॉड

Google के डेटा सेंटर में, TPU, हाई-परफ़ॉर्मेंस कंप्यूटिंग (एचपीसी) के इंटरकनेक्ट से जुड़े होते हैं. यह उन्हें एक बहुत बड़े एक्सेलरेटर के तौर पर दिखा सकता है. Google इन्हें पॉड कहता है. इनमें 512 TPU v2 कोर या 2048 TPU v3 कोर तक शामिल हो सकते हैं..

इलस्ट्रेशन: TPU v3 पॉड. एचपीसी इंटरकनेक्ट के ज़रिए जुड़े हुए TPU बोर्ड और रैक.

ट्रेनिंग के दौरान, ऑल-रिड्यूस एल्गोरिदम का इस्तेमाल करके, TPU कोर के बीच ग्रेडिएंट एक्सचेंज किए जाते हैं ( OK-reduce यहां बेहतर तरीके से बताया गया है). जिस मॉडल को ट्रेनिंग दी जा रही है वह बड़े बैच साइज़ पर ट्रेनिंग करके, हार्डवेयर का फ़ायदा ले सकता है.

इलस्ट्रेशन: Google TPU के 2-D टॉरोइडल मेश एचपीसी नेटवर्क पर ऑल-रिड्यूस एल्गोरिदम का इस्तेमाल करके, ट्रेनिंग के दौरान ग्रेडिएंट का सिंक करना.

सॉफ़्टवेयर

बड़े बैच साइज़ की ट्रेनिंग

हर TPU कोर के लिए, TPU के बैच का साइज़ 128 डेटा आइटम होता है. हालांकि, हर TPU कोर के लिए आठ डेटा आइटम होने की वजह से, हार्डवेयर पहले से ही उसका सही इस्तेमाल दिखा सकता है. याद रखें कि एक Cloud TPU में 8 कोर होते हैं.

इस कोड लैब में, हम Keras API का इस्तेमाल करेंगे. Keras में, आपका तय किया गया बैच, पूरे TPU का ग्लोबल बैच साइज़ होता है. आपके बैच अपने-आप आठ में बंट जाएंगे और TPU के 8 कोर पर चलते रहेंगे.

परफ़ॉर्मेंस से जुड़ी अन्य सलाह के लिए, TPU की परफ़ॉर्मेंस गाइड देखें. बहुत बड़े बैच साइज़ के लिए, कुछ मॉडल में खास देखभाल की ज़रूरत हो सकती है. ज़्यादा जानकारी के लिए, LARSOptimizer पर जाएं.

हुड के बारे में: एक्सएलए

Tensorflow प्रोग्राम, कंप्यूटेशन के ग्राफ़ को तय करते हैं. TPU, सीधे Python कोड नहीं चलाता है. यह आपके Tensorflow प्रोग्राम के हिसाब से कंप्यूटेशन ग्राफ़ चलाता है. हुड के तहत, XLA (Accelerated लीनियर अल्जेब्रा कंपाइलर) नाम का कंपाइलर, कंप्यूटेशन नोड के Tensorflow ग्राफ़ को TPU मशीन कोड में बदल देता है. यह कंपाइलर आपके कोड और मेमोरी लेआउट पर कई बेहतर ऑप्टिमाइज़ेशन भी करता है. TPU को काम भेजते ही, डेटा कंपाइल हो जाता है. आपको अपनी बिल्ड चेन में XLA को साफ़ तौर पर शामिल करने की ज़रूरत नहीं है.

इलस्ट्रेशन: TPU पर चलाने के लिए, आपके Tensorflow प्रोग्राम के तय किए गए कंप्यूटेशन ग्राफ़ को सबसे पहले XLA (एक्सेलरेटेड लीनियर अलजेब्रा कंपाइलर) में अनुवाद किया जाता है. इसके बाद, एक्सएलए की मदद से टीपीयू मशीन कोड में कंपाइल किया जाता है.

Keras में TPU इस्तेमाल करना

Tensorflow 2.1 के बाद से, TPU, Keras API के साथ काम करते हैं. Keras से जुड़ी सहायता, TPU और 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.Dataset API का इस्तेमाल करना ज़रूरी है.
TPU बहुत तेज़ी से काम करते हैं. ऐसे में डेटा को इन पर इस्तेमाल करते समय, डेटा अपने-आप घुल-मिल जाता है. TPU की परफ़ॉर्मेंस गाइड में, डेटा से जुड़ी रुकावटों का पता लगाने और परफ़ॉर्मेंस से जुड़ी अन्य सलाह पाने के लिए, कुछ टूल उपलब्ध हैं.
int8 या int16 नंबर को int32 माना जाता है. TPU में 32 बिट से कम का इंटीजर हार्डवेयर नहीं है.
Tensorflow की कुछ कार्रवाइयां काम नहीं करतीं. सूची यहां दी गई है. अच्छी बात यह है कि यह पाबंदी सिर्फ़ ट्रेनिंग कोड, जैसे कि आपके मॉडल के आगे और पीछे वाले पास पर लागू होती है. हालांकि, Tensorflow से जुड़ी सभी कार्रवाइयों को डेटा इनपुट पाइपलाइन में इस्तेमाल किया जा सकता है, क्योंकि ये कार्रवाइयां सीपीयू पर की जाएंगी.
tf.py_func, TPU पर काम नहीं करता.

4. [INFO] न्यूरल नेटवर्क क्लासिफ़ायर 101

कम शब्दों में

अगर अगले पैराग्राफ़ में बोल्ड में दिए गए सभी शब्द पहले से ही आपके बारे में हैं, तो अगले अभ्यास पर जाएं. अगर आपने अभी डीप लर्निंग शुरू की है, तो आपका स्वागत है. कृपया आगे पढ़ें.

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

Keras लेयर के क्रम के तौर पर बनाए गए मॉडल के लिए, सिक्वेंशियल एपीआई उपलब्ध कराया जाता है. उदाहरण के लिए, तीन सघन लेयर वाले इमेज क्लासिफ़ायर को 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 कहा जाता है. यह एक बहुत ही आसान फ़ंक्शन है, जिसे ऊपर दिए गए ग्राफ़ में देखा जा सकता है.

सॉफ़्टमैक्स ऐक्टिवेशन

ऊपर दिया गया नेटवर्क, 5-न्यूरॉन लेयर पर खत्म होता है, क्योंकि हम फूलों को पांच कैटगरी (रोज़, ट्यूलिप, डैंडलायन, डेज़ी, सनफ़्लावर) में बांट रहे हैं. इंटरमीडिएट लेयर में न्यूरॉन, क्लासिक RELU ऐक्टिवेशन फ़ंक्शन का इस्तेमाल करके चालू किए जाते हैं. हालांकि, आखिरी लेयर में हम 0 और 1 के बीच की संख्याओं का हिसाब लगाना चाहते हैं. इससे पता चलता है कि इस फूल के गुलाब, ट्यूलिप वगैरह होने की संभावना है. इसके लिए, हम "softmax" नाम के ऐक्टिवेशन फ़ंक्शन का इस्तेमाल करेंगे.

किसी वेक्टर पर सॉफ़्टमैक्स को लागू करने के लिए, हर एलिमेंट का एक्सपोनेन्शियल निकालें और फिर वेक्टर को नॉर्मलाइज़ किया जाता है. ऐसा आम तौर पर, L1 नॉर्म (निरपेक्ष मानों का योग) का इस्तेमाल करके किया जाता है, ताकि मानों को 1 तक जोड़ा जा सके और उन्हें प्रायिकता के रूप में समझा जा सके.

"सॉफ़्टमैक्स" क्यों है? सॉफ़्टमैक्स को कैसे कहते हैं? चरघातांकी फलन का काफ़ी तेज़ी से बढ़ने वाला है. इससे न्यूरॉन आउटपुट के बीच अंतर बढ़ जाएगा. इसके बाद, जब वेक्टर को नॉर्मलाइज़ किया जाता है, तो सबसे बड़े एलिमेंट, जो स्टैंडर्ड पर हावी होते हैं, को 1 के करीब की वैल्यू पर नॉर्मलाइज़ किया जाएगा. वहीं, बाकी सभी एलिमेंट को एक बड़ी वैल्यू से भाग देकर, 0 के आस-पास के लिए नॉर्मलाइज़ किया जाएगा. नतीजे के तौर पर मिलने वाला वेक्टर साफ़ तौर पर दिखाता है कि कौनसी क्लास विजेता है, यानी सबसे ज़्यादा वैल्यू. हालांकि, वैल्यू "सॉफ़्ट" हैं, लेकिन वैल्यू की ओरिजनल वैल्यू में कोई बदलाव नहीं हुआ है.

क्रॉस-एंट्रॉपी लॉस

अब जब हमारा न्यूरल नेटवर्क इनपुट इमेज से अनुमान लगाता है, तो हमें यह मापना होता है कि वे कितने अच्छे हैं, यानी कि नेटवर्क हमें जो जानकारी देता है और सही जवाबों के बीच की दूरी, उन्हें अक्सर "लेबल" कहा जाता है. याद रखें कि डेटासेट में मौजूद सभी इमेज के लिए, हमारे पास सही लेबल हैं.

किसी भी दूरी से काम किया जा सकता है. हालांकि, अलग-अलग कैटगरी में बांटने से जुड़ी समस्याओं के लिए, तथाकथित "क्रॉस-एंट्रॉपी दूरी" सबसे ज़्यादा असरदार है. हम इसे अपनी गड़बड़ी या "लॉस" कहेंगे फ़ंक्शन:

"वन-हॉट" एन्कोडिंग का मतलब है कि आप "3) डैंडलायन" लेबल का प्रतिनिधित्व करते हैं इसके लिए, 5 वैल्यू के वेक्टर का इस्तेमाल किया जाता है. इसमें तीसरे वैल्यू (1) को छोड़कर, बाकी सभी शून्य होते हैं. यह वेक्टर, डैंडलायन होने की 100% संभावना दिखाता है. हमारा न्यूरल नेटवर्क भी अपने अनुमान को 5 प्रॉबबिलिटी वैल्यू के वेक्टर के रूप में दिखाता है. इनकी तुलना करना आसान होता है.

ग्रेडिएंट डिसेंट

"ट्रेनिंग" न्यूरल नेटवर्क का मतलब है, ट्रेनिंग इमेज और लेबल का इस्तेमाल करके वज़न और पक्षपात को अडजस्ट करना, ताकि क्रॉस-एंट्रॉपी लॉस फ़ंक्शन को कम किया जा सके. यह सुविधा इस तरह से काम करती है.

क्रॉस-एंट्रॉपी में वज़न, पक्षपात, ट्रेनिंग इमेज के पिक्सल, और उसकी क्लास की जानकारी होती है.

अगर हम सभी वेट और सभी पूर्वाग्रहों के सापेक्ष क्रॉस-एंट्रॉपी के आंशिक डेरिवेटिव का हिसाब लगाते हैं, तो हमें दी गई इमेज, लेबल, और भार और पक्षपात के मौजूदा मान के लिए एक "ग्रेडिएंट" मिलता है. याद रखें कि हमारे पास लाखों वज़न और पूर्वाग्रह हो सकते हैं, इसलिए ग्रेडिएंट की गणना करना बहुत बड़ा काम है. अच्छी बात यह है कि Tensorflow हमारे लिए यह काम करता है. ग्रेडिएंट की गणितीय प्रॉपर्टी यह है कि यह "ऊपर" को पॉइंट करता है. चूंकि हम वहां जाना चाहते हैं जहां क्रॉस-एंट्रॉपी कम है, इसलिए हम इसके विपरीत दिशा में जाते हैं. हम ग्रेडिएंट के एक अंश के द्वारा वज़न और पूर्वाग्रह अपडेट करते हैं. इसके बाद, हम ट्रेनिंग लूप में, ट्रेनिंग की इमेज और लेबल के अगले बैच का इस्तेमाल करके, इस काम को बार-बार करते हैं. उम्मीद है कि यह ऐसी जगह इकट्ठा होता है जहां क्रॉस-एंट्रॉपी बहुत कम होती है. हालांकि, इस बात की गारंटी नहीं है कि यह कम से कम यूनीक होगा.

ग्रेडिएंट descent2.png

"लर्निंग रेट": हर बार दोहराए जाने पर, ग्रेडिएंट की पूरी लंबाई के हिसाब से अपने वेट और बायस को अपडेट नहीं किया जा सकता. ऐसा लगता है कि सात लीग वाले बूट पहनकर, घाटी के निचले हिस्से में जाने की कोशिश की जा रही है. ऐसा हो सकता है कि आप घाटी के एक से दूसरे हिस्से पर जाएं. सबसे नीचे जाने के लिए, आपको छोटे चरण करने होंगे, यानी कि ग्रेडिएंट के सिर्फ़ एक अंश का इस्तेमाल करना होगा, जो आम तौर पर 1/1000 वाली रेंज में होता है. इस अंश को "शिक्षण दर" कहा जाता है.

मिनी बैचिंग और मोमेंटम

आप सिर्फ़ एक उदाहरण इमेज पर अपने ग्रेडिएंट का हिसाब लगा सकते हैं और महत्व और पक्षपात को तुरंत अपडेट कर सकते हैं, लेकिन उदाहरण के लिए, 128 इमेज के बैच पर ऐसा करने से ग्रेडिएंट मिलता है, जो अलग-अलग उदाहरण वाली इमेज के ज़रिए लागू किए गए कंस्ट्रेंट को बेहतर तरीके से दिखाता है और इससे समाधान ज़्यादा तेज़ी से जुड़ सकता है. मिनी-बैच के साइज़ में बदलाव किया जा सकता है.

इस तकनीक को "स्टोकैस्टिक ग्रेडिएंट डिसेंट" भी कहा जाता है इसका दूसरा और व्यावहारिक फ़ायदा है: बैच के साथ काम करने का मतलब है बड़े मैट्रिक्स पर काम करना. आम तौर पर, इन्हें जीपीयू और टीपीयू पर ऑप्टिमाइज़ करना आसान होता है.

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

इलस्ट्रेशन: सैडल पॉइंट. ग्रेडिएंट 0 है लेकिन यह सभी दिशाओं में कम से कम नहीं है. (इमेज एट्रिब्यूशन Wikimedia: by Nicoguro - अपना काम, CC BY 3.0)

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

शब्दावली

बैच या मिनी-बैच: ट्रेनिंग, हमेशा ट्रेनिंग डेटा और लेबल के बैच पर की जाती है. ऐसा करने से एल्गोरिदम को एक जैसी चीज़ों के बारे में जानने में मदद मिलती है. "बैच" डाइमेंशन आम तौर पर, डेटा टेंसर का पहला डाइमेंशन होता है. उदाहरण के लिए, आकार के टेंसर [100, 192, 192, 3] में 192x192 पिक्सल की 100 इमेज होती हैं, जिनमें हर पिक्सल (RGB) में तीन वैल्यू होती हैं.

क्रॉस-एंट्रॉपी लॉस: एक खास लॉस फ़ंक्शन जिसका इस्तेमाल अक्सर क्लासिफ़ायर में किया जाता है.

गहन लेयर: न्यूरॉन की एक लेयर, जहां हर न्यूरॉन, पिछली लेयर में मौजूद सभी न्यूरॉन से जुड़ा होता है.

सुविधाएं: न्यूरल नेटवर्क के इनपुट को कभी-कभी "सुविधाएं" कहा जाता है. "फ़ीचर इंजीनियरिंग", यह पता लगाने की कला को "फ़ीचर इंजीनियरिंग" कहा जाता है. इसकी मदद से यह पता लगाया जा सकता है कि बेहतर अनुमान पाने के लिए, न्यूरल नेटवर्क में डेटासेट के किन हिस्सों या हिस्सों के कॉम्बिनेशन को फ़ीड किया जाए.

लेबल: "क्लास" के लिए एक और नाम या निगरानी में रखे गए क्लासिफ़िकेशन की समस्या में दिए गए जवाबों को सही करना

लर्निंग रेट: ग्रेडिएंट का वह हिस्सा जिसके हिसाब से ट्रेनिंग लूप में होने वाली हर प्रोसेस पर वेट और बायस को अपडेट किया जाता है.

logits: ऐक्टिवेशन फ़ंक्शन लागू होने से पहले, न्यूरॉन की एक लेयर के आउटपुट को "लॉगिट" कहा जाता है. यह शब्द "लॉजिस्टिक फ़ंक्शन" से आता है "सिगमॉइड फ़ंक्शन" जो सबसे लोकप्रिय ऐक्टिवेशन फ़ंक्शन हुआ करता था. "लॉजिस्टिक फ़ंक्शन से पहले न्यूरॉन आउटपुट" को छोटा करके "logits" कर दिया गया.

लॉस: गड़बड़ी का फ़ंक्शन, न्यूरल नेटवर्क आउटपुट की तुलना सही जवाबों से करता है

न्यूरॉन: यह अपने इनपुट के भारित योग का आकलन करता है, पूर्वाग्रह जोड़ता है और ऐक्टिवेशन फ़ंक्शन के ज़रिए नतीजे को फ़ीड करता है.

वन-हॉट एन्कोडिंग: 5 में से 3 क्लास को 5 एलिमेंट के वेक्टर के तौर पर एन्कोड किया जाता है. इसमें तीसरे एलिमेंट को छोड़कर, बाकी सभी शून्य होते हैं, यानी कि 1.

relu: सुधारी गई लीनियर यूनिट. न्यूरॉन के लिए एक लोकप्रिय ऐक्टिवेशन फ़ंक्शन.

sigmoid: ऐक्टिवेशन का एक और ऐसा फ़ंक्शन जो पहले लोकप्रिय हुआ था और खास मामलों में अब भी काम का है.

सॉफ़्टमैक्स: यह एक खास ऐक्टिवेशन फ़ंक्शन है, जो वेक्टर पर काम करता है. यह सबसे बड़े कॉम्पोनेंट और बाकी सभी के बीच के अंतर को बढ़ाता है. साथ ही, वेक्टर को 1 का योग करने के लिए नॉर्मलाइज़ करता है, ताकि इसे प्रॉबबिलिटी के वेक्टर के रूप में समझा जा सके. इसका इस्तेमाल क्लासिफ़ायर में आखिरी चरण के तौर पर किया जाता है.

टेन्सर: एक "टेंसर" आव्यूह की तरह होता है, लेकिन डाइमेंशन की संख्या आर्बिट्रेरी होती है. 1-डाइमेंशन वाला टेंसर एक वेक्टर होता है. 2-डाइमेंशन टेंसर एक मैट्रिक्स होता है. इसके बाद, आपके पास 3, 4, 5 या उससे ज़्यादा डाइमेंशन वाले टेंसर हो सकते हैं.

5. [INFO] कॉन्वोलूशनल न्यूरल नेटवर्क

कम शब्दों में

अगर अगले पैराग्राफ़ में बोल्ड में दिए गए सभी शब्द पहले से ही आपके बारे में हैं, तो अगले अभ्यास पर जाएं. अगर आप कॉन्वलूशनल न्यूरल नेटवर्क से अभी शुरुआत कर रहे हैं, तो कृपया आगे पढ़ें.

इलस्ट्रेशन: किसी इमेज को 4x4x3=48 सीखने लायक वज़न से बने दो फ़िल्टर के साथ फ़िल्टर करना.

कॉन्वोलूशनल न्यूरल नेटवर्क इनपुट इमेज में सीखने लायक फ़िल्टर की सीरीज़ लागू करते हैं. कॉन्वोलूशनल लेयर को फ़िल्टर (या कर्नेल) के साइज़, लगाए गए फ़िल्टर की संख्या, और स्ट्राइड से तय किया जाता है. कॉन्वोलूशन लेयर के इनपुट और आउटपुट में तीन डाइमेंशन (चौड़ाई, ऊंचाई, चैनलों की संख्या) होते हैं. इसकी शुरुआत इनपुट इमेज (चौड़ाई, ऊंचाई, आरजीबी चैनल) से होती है. कॉन्वोलूशनल लेयर को स्टैक करते समय, आउटपुट की चौड़ाई और ऊंचाई को स्ट्राइड >1 का इस्तेमाल करके या मैक्स-पूलिंग ऑपरेशन की मदद से किया जा सकता है. आउटपुट की डेप्थ (चैनलों की संख्या), ज़्यादा या कम फ़िल्टर का इस्तेमाल करके अडजस्ट की जाती है.

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'])

कॉन्वलूशनल न्यूरल नेट्स 101

कॉन्वलूशनल नेटवर्क की लेयर में, एक "न्यूरॉन" सिर्फ़ इमेज के छोटे से क्षेत्र में, इसके ठीक ऊपर पिक्सल का वेटेड योग करता है. यह पूर्वाग्रह जोड़ता है और ऐक्टिवेशन फ़ंक्शन के ज़रिए योग को फ़ीड करता है, जैसा कि किसी नियमित सघन परत में मौजूद न्यूरॉन करता है. फिर यह कार्रवाई एक ही वेट का इस्तेमाल करके पूरी इमेज में दोहराई जाती है. याद रखें कि घनी लेयर में, हर एक न्यूरॉन का अपना वज़न होता है. यहाँ, एक "पैच" दोनों दिशाओं में इमेज पर वज़न की स्लाइड (एक "संकलन") का इस्तेमाल करें. आउटपुट में उतनी वैल्यू होती हैं जितनी इमेज में पिक्सल होती हैं. हालांकि, किनारों पर कुछ पैडिंग (जगह) ज़रूरी है. यह 4x4x3=48 मोटाई वाले फ़िल्टर का इस्तेमाल करके, फ़िल्टर करने की एक कार्रवाई होती है.

हालांकि, 48 भार काफ़ी नहीं होंगे. ज़्यादा आज़ादी की कार्रवाई जोड़ने के लिए, हम इसी कार्रवाई को एक नए सेट के साथ दोहराते हैं. इससे, फ़िल्टर आउटपुट का एक नया सेट बनता है. इसे "चैनल" कहते हैं आउटपुट के लिए, इनपुट इमेज में R,G,B चैनल से जुड़े हैं.

Screen Shot 2016-07-29: 16.02.37.png

कोई नया डाइमेंशन जोड़कर, वज़न के दो या उससे ज़्यादा सेट को एक टेंसर के तौर पर जोड़ा जा सकता है. इससे हमें कॉन्वलूशन लेयर के लिए, वेट टेंसर का सामान्य आकार मिलता है. इनपुट और आउटपुट चैनल की संख्या पैरामीटर हैं. इसलिए, हम कॉन्वोलूशनल लेयर को स्टैक और चेन करना शुरू कर सकते हैं.

इलस्ट्रेशन: कॉन्वलूशनल न्यूरल नेटवर्क, "क्यूब्स" को बदल देता है डेटा को दूसरे "क्यूब" में बदल देते हैं का डेटा इस्तेमाल किया जाता है.

स्टैंडेड कॉन्वोलूशन, ज़्यादा से ज़्यादा पूल करना

2 या 3 की चाल के साथ कन्वर्ज़न करने पर, हम मिलने वाले डेटा क्यूब को हॉरिज़ॉन्टल डाइमेंशन में छोटा भी कर सकते हैं. इसे करने के दो सामान्य तरीके हैं:

स्ट्राइड कनवलूशन: ऊपर की तरह स्लाइडिंग फ़िल्टर, लेकिन स्ट्राइड >1 के साथ
अधिकतम पूलिंग: MAX ऑपरेशन लागू करने वाली स्लाइड करने वाली विंडो (आम तौर पर 2x2 पैच पर, हर 2 पिक्सेल में दोहराया जाता है)

इलस्ट्रेशन: कंप्यूटिंग विंडो को तीन पिक्सल स्लाइड करने से आउटपुट वैल्यू कम हो जाती हैं. स्ट्राइड्ड कन्वर्ज़न या मैक्स पूलिंग, हॉरिज़ॉन्टल डाइमेंशन में डेटा क्यूब को छोटा करने का एक तरीका है. मैक्स पूलिंग का मतलब है कि विंडो को 2x2 वाली विंडो के एक हिस्से से दूसरे बार स्लाइड करना होगा.

"मैक्स-पूलिंग" कॉन्वलूशनल नेटवर्क कैसे काम करते हैं, इसे समझने में हमारी मदद कर सकती है: अगर ट्रेनिंग के दौरान, वेट के पैच ऐसे फ़िल्टर में बदल जाते हैं जो बुनियादी आकारों (हॉरिज़ॉन्टल और वर्टिकल लाइन, कर्व, ...) की पहचान करते हैं, तो काम की जानकारी को लेयर के ज़रिए हम तक पहुंचा देते हैं. इससे आउटपुट की सबसे ज़्यादा इंटेंसिटी के साथ शेप की पहचान की जाती है. व्यावहारिक तौर पर, मैक्स-पूल लेयर न्यूरॉन आउटपुट में, 2x2 के ग्रुप में प्रोसेस किया जाता है और सिर्फ़ सबसे बड़ी वैल्यू ही रखी जाती है.

ऑनवोलूशनल क्लासिफ़ायर

आखिर में, हम आखिरी डेटा क्यूब को समतल करके और उसे एक सघन, सॉफ़्टमैक्स-एक्टिव लेयर के ज़रिए फ़ीड करके, क्लासिफ़िकेशन हेड को अटैच करते हैं. एक सामान्य कॉन्वोलूशनल क्लासिफ़ायर ऐसा दिख सकता है:

इलस्ट्रेशन: इमेज की कैटगरी तय करने वाला एल्गोरिदम, जिसमें कन्वर्ज़न और सॉफ़्टमैक्स लेयर का इस्तेमाल किया गया है. इसमें 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 कॉन्वोल्यूशन लेयर या लेयर का कोई अलग कॉम्बिनेशन? इन सभी को आज़माएं, नतीजे जोड़ें, और नेटवर्क को तय करने दें. दाईं ओर: " इनसेप्शन" ऐसे मॉड्यूल का इस्तेमाल करते हुए कंवोलूशनल आर्किटेक्चर का इस्तेमाल करते हैं.

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 API की मदद से, 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% सटीक जानकारी अब पहुंच में होनी चाहिए.

समाधान

समाधान notebook यहां दी गई है. कोई समस्या आने पर, इसका इस्तेमाल किया जा सकता है.

Keras_Flowers_TPU_squeezenet.ipynb

इसमें हमने इन विषयों के बारे में बताया

🤔 Keras "फ़ंक्शनल स्टाइल" मॉडल
🤓 स्क्वीज़नेट आर्किटेक्चर
🤓 tf.data.datset की मदद से डेटा को बेहतर बनाने की सुविधा

कृपया कुछ समय निकालकर इस चेकलिस्ट को देखें.

8. Xception को फ़ाइन-ट्यून किया गया

अलग-अलग करने लायक कन्वर्ज़न

कॉन्वोलूशनल लेयर को लागू करने का एक अलग तरीका हाल ही में लोकप्रिय हो रहा है: डेप्थ से लिंक किए जा सकने वाले कन्वर्ज़न. मुझे पता है यह भले ही मज़ेदार है, लेकिन इसका सिद्धांत बहुत आसान है. इन्हें Tensorflow और Keras में tf.keras.layers.SeparableConv2D के तौर पर लागू किया जाता है.

अलग किया जा सकने वाला कन्वर्ज़न, इमेज पर भी एक फ़िल्टर चलाता है. हालांकि, यह इनपुट इमेज के हर चैनल के लिए, अलग-अलग वेटेज का इस्तेमाल करता है. यह "1x1 कॉन्वलूशन" के बाद, डॉट प्रॉडक्ट की एक सीरीज़ होती है. इससे, फ़िल्टर किए गए चैनलों का कुल योग तय होता है. हर बार नए वेट के साथ, चैनलों के वेटेड रीकॉम्बिनेशन को ज़रूरत के हिसाब से कैलकुलेट किया जाता है.

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

अलग किए जा सकने वाले कन्वर्ज़न का इस्तेमाल, सबसे हाल के कॉन्वलूशनल नेटवर्क आर्किटेक्चर में किया जाता है: MobileNetV2, Xception, FunctionNet. वैसे, 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 में, लर्निंग रेट को कॉलबैक की मदद से बताया जाता है. इसमें हर epoch के लिए, लर्निंग रेट का हिसाब लगाया जा सकता है. Keras हर epoch के लिए, ऑप्टिमाइज़र को सीखने की सही दर पास करेगा.

def lr_fn(epoch):
  lr = ...
  return lr

lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_fn, verbose=True)

model.fit(..., callbacks=[lr_callback])

समाधान

समाधान notebook यहां दी गई है. कोई समस्या आने पर, इसका इस्तेमाल किया जा सकता है.

07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

इसमें हमने इन विषयों के बारे में बताया

🤔 गहराई से अलग किया जा सकने वाला कन्वर्ज़न
🤓 सीखने की दर के शेड्यूल
❌ पहले से ट्रेन किए गए मॉडल को बेहतर बनाना.

कृपया कुछ समय निकालकर इस चेकलिस्ट को देखें.

9. बधाई हो!

आपने अपना पहला आधुनिक कॉन्वोलूशनल न्यूरल नेटवर्क बनाया है और उसे 90% + सटीक बनाने की ट्रेनिंग दी है. TPU की बदौलत, आपने कुछ ही मिनटों में ट्रेनिंग को पूरा कर लिया है. इसके बाद, "TPU कोडलैब पर केरस" के चार इवेंट खत्म हुए:

TPU-स्पीड डेटा पाइपलाइन: tf.data.Dataset और TFRecords
ट्रांसफ़र लर्निंग के साथ आपका पहला Keras मॉडल
केरास और टीपीयू के साथ कनवलूशनल न्यूरल नेटवर्क
[THIS LAB] केराज़ और TPU के साथ मॉडर्न कन्वर्ज़न, स्क्विज़नेट, Xception

मौजूदा TPU

TPU और जीपीयू, Cloud AI Platform पर उपलब्ध हैं:

डीप लर्निंग वीएम पर
AI Platform Notebooks में
एआई प्लैटफ़ॉर्म की ट्रेनिंग से जुड़ी नौकरियों के लिए

आखिर में, हमें सुझाव, राय या शिकायत ज़रूर भेजें. अगर आपको इस लैब में कोई गड़बड़ी दिखती है या आपको लगता है कि इसमें सुधार किया जाना चाहिए, तो कृपया हमें बताएं. GitHub की समस्याओं के ज़रिए, सुझाव या राय दी जा सकती है [ feedback link].

मार्टिन गॉर्नर आईडी छोटा.jpg
लेखक: मार्टिन गॉर्नर
Twitter: @martin_gorner

tensorflow लोगो.jpg
www.tensorflow.org