Keras और TPU के साथ कॉन्वोलूशनल न्यूरल नेटवर्क

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

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

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

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

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

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

• Keras क्रमिक मॉडल का इस्तेमाल करके कनवलूशनल इमेज क्लासिफ़ायर बनाने के लिए.
• TPU पर अपने Keras मॉडल को ट्रेनिंग देने के लिए
• कॉन्वलूशनल लेयर के अच्छे विकल्प के साथ, अपने मॉडल को बेहतर बनाने के लिए.

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

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

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

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

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

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

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

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

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

Tensorflow लाइब्रेरी में ऑप्टिमाइज़र की पूरी रेंज मौजूद है, जो tf.train.GradientDescentOptimizer से शुरू होती है. tf.train.RMSPropOptimizer या tf.train.AdamOptimizer ज़्यादा बेहतर लोकप्रिय ऑप्टिमाइज़र होते हैं, जो लोगों में दिलचस्पी बनाए रखते हैं.

शब्दावली

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5. [नई जानकारी] कॉन्वॉल्यूशन न्यूरल नेटवर्क

कम शब्दों में

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

इलस्ट्रेशन: किसी इमेज को 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 चैनल से जुड़े हैं.

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

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

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

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

कॉन्वलूशनल लेयर में पैडिंग पैरामीटर की दो वैल्यू हो सकती हैं:

• "same": शून्य वाले पैड ताकि इनपुट के समान चौड़ाई/ऊंचाई के आउटपुट दे सके
• "मान्य": कोई पैडिंग नहीं, सिर्फ़ वास्तविक पिक्सल का इस्तेमाल करें

6. आपका कस्टम कन्वर्ज़न

हैंड्स-ऑन

आइए, शुरू से एक कॉन्वलूशनल न्यूरल नेटवर्क बनाएं और उसे ट्रेनिंग दें. TPU का इस्तेमाल करने पर, हम यह काम बहुत तेज़ी से कर पाएंगे. कृपया यहां दी गई नोटबुक खोलें, सेल (Shift-ENTER) चलाएं और जहां भी आपको "काम ज़रूरी है" दिखे वहां निर्देशों का पालन करें लेबल.

Keras_Flowers_TPU (playground).ipynb

इसका लक्ष्य ट्रांसफ़र लर्निंग मॉडल की 75% सटीक जानकारी से आगे निकलना है. उस मॉडल का एक फ़ायदा यह था कि उसे लाखों इमेज के डेटासेट की मदद से पहले से ट्रेनिंग दी गई, जबकि हमारे पास यहां सिर्फ़ 3670 इमेज हैं. क्या तुम कम से कम इसका मिलान कर सकते हो?

ज़्यादा जानकारी

कितनी लेयर, कितनी बड़ी हैं?

लेयर का साइज़ चुनना, विज्ञान से ज़्यादा कला है. आपको बहुत कम और बहुत ज़्यादा पैरामीटर (वेट और पूर्वाग्रह) के बीच सही संतुलन बनाना होगा. बहुत कम भार होने पर न्यूरल नेटवर्क, फूलों के आकारों की जटिलता को नहीं दिखा सकता. बहुत ज़्यादा होने पर, इसे "ओवरफ़िट" होने की आशंका हो सकती है. इसका मतलब है कि ट्रेनिंग वाली इमेज में महारत हासिल करना और सामान्य बनाने की जानकारी न होना. बहुत ज़्यादा पैरामीटर होने पर, मॉडल की ट्रेनिंग भी धीमी हो जाएगी. Keras में, model.summary() फ़ंक्शन आपके मॉडल की संरचना और पैरामीटर की संख्या दिखाता है:

Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 192, 192, 16)      448       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 192, 192, 30)      4350      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 96, 96, 60)        16260     
_________________________________________________________________
 ... 
_________________________________________________________________
global_average_pooling2d (Gl (None, 130)               0         
_________________________________________________________________
dense (Dense)                (None, 90)                11790     
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 455       
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________

कुछ सलाह:

• एक से ज़्यादा लेयर होने पर "गहरा" बनता है न्यूरल नेटवर्क असरदार हैं. फूलों की पहचान से जुड़ी इस आसान समस्या के लिए, 5 से 10 लेयर का होना सही है.
• छोटे फ़िल्टर का इस्तेमाल करें. आम तौर पर, 3x3 फ़िल्टर हर जगह अच्छे होते हैं.
• 1x1 फ़िल्टर का इस्तेमाल भी किया जा सकता है और ये सस्ते होते हैं. वे वाकई "फ़िल्टर" नहीं करते लेकिन चैनलों के लीनियर कॉम्बिनेशन की गणना करें. असली फ़िल्टर की मदद से उन्हें चुनें. (अगले सेक्शन में "1x1 कॉन्वोल्यूशन" के बारे में ज़्यादा जानकारी दी गई है.)
• इस तरह की क्लासिफ़िकेशन वाली समस्या के लिए, मैक्स-पूलिंग लेयर (या स्ट्राइड >1 वाले कॉन्वलूशन) के साथ अक्सर डाउनसैंपल करें. आपको इस बात की परवाह नहीं है कि फूल कहां है, सिर्फ़ यह कि वह गुलाब या डैंडलायन है, इसलिए x और y के बारे में जानकारी खोना अहम नहीं है और छोटे इलाकों को फ़िल्टर करना सस्ता है.
• फ़िल्टर की संख्या आम तौर पर, नेटवर्क के आखिर में मौजूद क्लास की संख्या के बराबर हो जाती है. नीचे "ग्लोबल औसत पूलिंग" ट्रिक देखें). अगर कैटगरी को सैकड़ों में बांटा गया है, तो फ़िल्टर की गिनती लगातार लेयर में बढ़ाई जा सकती है. फूलों के डेटासेट के लिए, सिर्फ़ पांच फ़िल्टर इस्तेमाल करना काफ़ी नहीं है. ज़्यादातर लेयर में फ़िल्टर की एक ही संख्या का इस्तेमाल किया जा सकता है, जैसे कि 32 और उसे आखिर में कम किया जा सकता है.
• सबसे घनी लेयर वाली लेयर महंगी है/हैं. इसका/उनका वज़न, सभी कॉन्वलूशनल लेयर के मुकाबले ज़्यादा हो सकता है. उदाहरण के लिए, 24x24x10 डेटा पॉइंट के आखिरी डेटा क्यूब से मिलने वाले आउटपुट के बावजूद, 100 न्यूरॉन डेंसिटी लेयर की लागत 24x24x10x100=5,76,000 वेट होगी !!! सोच-समझकर फ़ैसला लें या ग्लोबल ऐवरेज पूलिंग आज़माएं (नीचे देखें).

ग्लोबल औसत पूलिंग

कॉन्वोलूशनल न्यूरल नेटवर्क के आखिर में महंगी लेयर का इस्तेमाल करने के बजाय, आने वाले डेटा "क्यूब" को अलग करें उनकी वैल्यू को औसत करें और उन्हें सॉफ़्टमैक्स ऐक्टिवेशन फ़ंक्शन की मदद से फ़ीड करें. क्लासिफ़िकेशन हेड बनाने के इस तरीके में कोई वज़न नहीं होगा. Keras में सिंटैक्स tf.keras.layers.GlobalAveragePooling2D(). है

कॉन्वोलूशनल न्यूरल नेटवर्क, चीज़ों की लोकेशन का पता लगाते हैं. जब कोई फ़िल्टर किसी सुविधा का पूरी तरह से जवाब देता है, तो वह ऐसा किसी खास x,y जगह पर करता है. आप क्या करना चाहते हैं, इसके आधार पर न्यूरल नेटवर्क को इस जगह की जानकारी के डेटा को इस्तेमाल करने या खारिज करने के लिए ट्रेनिंग दी जा सकती है. ग्लोबल ऐवरेज पूलिंग का इस्तेमाल करने से, जगह की जानकारी का पूरा डेटा साफ़ तौर पर खारिज हो जाता है. यह फूलों की कैटगरी तय करने वाले टूल के लिए ठीक हो सकता है. हालांकि, हो सकता है कि यह दूसरे कामों के लिए न हो. जैसे, किसी इमेज में फूलों की गिनती करना. डिवाइस का इस्तेमाल सावधानी से करें.

समाधान

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

Keras_Flowers_TPU (solution).ipynb

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

• 🤔 कन्वर्ज़न लेयर के साथ चलाया गया
• 🤓 ज़्यादा से ज़्यादा पूल करने की सुविधा, स्ट्राइड, ग्लोबल औसत पूलिंग के प्रयोग किए गए, ...
• TPU पर, असल दुनिया के मॉडल पर तेज़ी से दोहराया गया

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

7. बधाई हो!

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

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

मौजूदा TPU

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

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

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

लेखक: मार्टिन गॉर्नर Twitter: @martin_gorner

www.tensorflow.org