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

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

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

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

यह लैब, "TPU पर Keras" सीरीज़ का तीसरा हिस्सा है. इन्हें इस क्रम में या अलग-अलग किया जा सकता है.

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

आपको क्या सीखने को मिलेगा

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

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

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

2. Google Colaboratory को तुरंत शुरू करना

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

इस सैंपल नोटबुक को खोलकर, कुछ सेल चलाएं. इससे आपको Colaboratory के बारे में जानकारी मिलेगी.

Welcome to Colab.ipynb

कोई टीपीयू बैकएंड चुनना

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

नोटबुक को एक्ज़ीक्यूट करना

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

विषय सूची

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

छिपे हुए सेल

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

पुष्टि करना

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

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

कम शब्दों में

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

Keras में TPU पर मॉडल को ट्रेन करने का कोड (अगर TPU उपलब्ध नहीं है, तो GPU या CPU पर वापस आएं):

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 का इस्तेमाल क्यों करें ?

मॉडर्न जीपीयू, प्रोग्राम किए जा सकने वाले "कोर" के हिसाब से व्यवस्थित किए जाते हैं. यह एक बहुत ही फ़्लेक्सिबल आर्किटेक्चर है. इसकी मदद से, कई तरह के टास्क मैनेज किए जा सकते हैं. जैसे, 3D रेंडरिंग, डीप लर्निंग, फ़िज़िकल सिमुलेशन वगैरह. दूसरी ओर, टीपीयू एक क्लासिक वेक्टर प्रोसेसर को एक खास मैट्रिक्स मल्टिप्लाई यूनिट के साथ जोड़ते हैं. साथ ही, वे ऐसे किसी भी टास्क में बेहतर परफ़ॉर्म करते हैं जहां मैट्रिक्स मल्टिप्लिकेशन का इस्तेमाल ज़्यादा होता है. जैसे, न्यूरल नेटवर्क.

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

हार्डवेयर

MXU और VPU

TPU v2 कोर, मैट्रिक्स मल्टिप्लाई यूनिट (एमएक्सयू) से बनी होती है. यह मैट्रिक्स मल्टिप्लिकेशन को चलाती है. साथ ही, इसमें एक वेक्टर प्रोसेसिंग यूनिट (वीपीयू) होती है, जो अन्य सभी टास्क के लिए होती है. जैसे, ऐक्टिवेशन, सॉफ़्टमैक्स वगैरह. वीपीयू, फ़्लोट32 और int32 कंप्यूटेशन को हैंडल करता है. दूसरी ओर, MXU 16-32 बिट फ़्लोटिंग पॉइंट फ़ॉर्मैट में काम करता है.

मिक्सड प्रिसिशन फ़्लोटिंग पॉइंट और bfloat16

MXU, bfloat16 इनपुट और float32 आउटपुट का इस्तेमाल करके, मैट्रिक्स के गुणनफल की गणना करता है. इंटरमीडिएट एक्युमुलेशन, फ़्लोट32 प्रिसिशन में किए जाते हैं.

आम तौर पर, न्यूरल नेटवर्क ट्रेनिंग पर फ़्लोटिंग पॉइंट की कम सटीक वैल्यू से होने वाले नॉइज़ का असर नहीं पड़ता. ऐसे मामले भी सामने आए हैं जिनमें नॉइज़ से ऑप्टिमाइज़र को कन्वर्ज होने में मदद मिलती है. आम तौर पर, कंप्यूटेशन को तेज़ करने के लिए 16-बिट फ़्लोटिंग पॉइंट प्रेसिज़न का इस्तेमाल किया जाता है. हालांकि, float16 और float32 फ़ॉर्मैट की रेंज बहुत अलग होती हैं. आम तौर पर, float32 से float16 में बदलने पर, ओवरफ़्लो और अंडरफ़्लो की समस्याएं आती हैं. इसके समाधान मौजूद हैं, लेकिन float16 को काम करने के लिए आम तौर पर अतिरिक्त काम करना पड़ता है.

इसलिए, Google ने टीपीयू में bfloat16 फ़ॉर्मैट पेश किया है. bfloat16, float32 का छोटा किया गया वर्शन है. इसमें एक्स्पोनेंट बिट और रेंज, float32 के जैसी ही होती है. इसके अलावा, टीपीयू bfloat16 इनपुट के साथ मिक्स्ड प्रिसिशन में मैट्रिक्स मल्टिप्लिकेशन की गणना करते हैं, लेकिन float32 आउटपुट देते हैं. इसका मतलब है कि आम तौर पर, कम प्रिसिशन से परफ़ॉर्मेंस में होने वाले फ़ायदों का इस्तेमाल करने के लिए, कोड में कोई बदलाव करने की ज़रूरत नहीं होती.

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

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

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

Cloud TPU

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

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

TPU पॉड

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

इमेज: TPU v3 पॉड. एचपीसी इंटरकनेक्ट के ज़रिए कनेक्ट किए गए टीपीयू बोर्ड और रैक.

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

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

सॉफ़्टवेयर

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

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

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

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

बारीकियों के बारे में जानें: XLA

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

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

Keras में टीपीयू का इस्तेमाल करना

Tensorflow 2.1 से, Keras API के ज़रिए टीपीयू इस्तेमाल किए जा सकते हैं. Keras का इस्तेमाल, टीपीयू और टीपीयू पॉड पर किया जा सकता है. यहां एक ऐसा उदाहरण दिया गया है जो टीपीयू, जीपीयू, और सीपीयू पर काम करता है:

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() नेटवर्क पर टीपीयू ढूंढता है. यह ज़्यादातर Google Cloud सिस्टम पर पैरामीटर के बिना काम करता है. जैसे, AI Platform की नौकरियां, Colaboratory, Kubeflow, और ‘ctpu up' यूटिलिटी के ज़रिए बनाए गए डीप लर्निंग वीएम. इन सिस्टम को यह पता होता है कि उनका टीपीयू कहां है. ऐसा TPU_NAME एनवायरमेंट वैरिएबल की वजह से होता है. अगर आपको टीपीयू को मैन्युअल तरीके से बनाना है, तो टीपीयू का इस्तेमाल करने वाले वीएम पर TPU_NAME एनवायरमेंट वैरिएबल सेट करें. इसके अलावा, TPUClusterResolver को साफ़ तौर पर पैरामीटर के साथ कॉल करें: TPUClusterResolver(tp_uname, zone, project)
TPUStrategy, डिस्ट्रिब्यूशन और "ऑल-रिड्यूस" ग्रेडिएंट सिंक्रनाइज़ेशन एल्गोरिदम को लागू करने वाला हिस्सा है.
यह रणनीति, स्कोप के ज़रिए लागू की जाती है. मॉडल को strategy scope() के अंदर तय किया जाना चाहिए.
tpu_model.fit फ़ंक्शन को टीपीयू ट्रेनिंग के लिए, tf.data.Dataset ऑब्जेक्ट के तौर पर इनपुट की ज़रूरत होती है.

टीपीयू पर पोर्ट करने से जुड़े सामान्य टास्क

TensorFlow मॉडल में डेटा लोड करने के कई तरीके हैं. हालांकि, टीपीयू के लिए tf.data.Dataset एपीआई का इस्तेमाल करना ज़रूरी है.
टीपीयू बहुत तेज़ होते हैं. इसलिए, टीपीयू पर डेटा प्रोसेस करते समय, डेटा को प्रोसेस करने में लगने वाला समय सबसे ज़्यादा होता है. डेटा बॉटलनेक और परफ़ॉर्मेंस से जुड़ी अन्य सलाह का पता लगाने के लिए, टीपीयू परफ़ॉर्मेंस गाइड में दिए गए टूल का इस्तेमाल किया जा सकता है.
int8 या int16 संख्याओं को int32 के तौर पर माना जाता है. टीपीयू में, 32 बिट से कम पर काम करने वाला पूर्णांक हार्डवेयर नहीं होता.
Tensorflow की कुछ कार्रवाइयां काम नहीं करती हैं. सूची यहां दी गई है. अच्छी बात यह है कि यह सीमा सिर्फ़ ट्रेनिंग कोड पर लागू होती है. इसका मतलब है कि यह सीमा, आपके मॉडल के फ़ॉरवर्ड और बैकवर्ड पास पर लागू होती है. हालांकि, अब भी अपने डेटा इनपुट पाइपलाइन में सभी TensorFlow ऑपरेशनों का इस्तेमाल किया जा सकता है, क्योंकि इन्हें सीपीयू पर एक्ज़ीक्यूट किया जाएगा.
tf.py_func को टीपीयू पर इस्तेमाल नहीं किया जा सकता.

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

कम शब्दों में

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

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

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

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

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

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

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

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

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

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

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

क्रॉस-एंट्रॉपी, वेट, बायस, ट्रेनिंग इमेज के पिक्सल, और उसके जाने-पहचाने क्लास का फ़ंक्शन है.

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

gradient descent2.png

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

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

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

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

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

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

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

शब्दावली

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

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

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

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

लेबल: सुपरवाइज़्ड क्लासिफ़िकेशन की समस्या में "क्लास" या सही जवाबों का दूसरा नाम

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

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

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

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

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

relu: रेक्टिफ़ाइड लीनियर यूनिट. यह न्यूरॉन के लिए एक लोकप्रिय ऐक्टिवेशन फ़ंक्शन है.

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

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

टेंसर: "टेंसर" एक मैट्रिक्स की तरह होता है, लेकिन इसमें डाइमेंशन की संख्या कुछ भी हो सकती है. एक डाइमेंशन वाला टेंसर, वेक्टर होता है. दो डाइमेंशन वाला टेंसर, मैट्रिक्स होता है. इसके बाद, आपके पास 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'])

कन्वलूशनल न्यूरल नेटवर्क के बारे में बुनियादी जानकारी

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

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

Screen Shot 2016-07-29 at 16.02.37.png

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

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

स्ट्राइड कन्वलूशन, मैक्स पूलिंग

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

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

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

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

Convolutional classifier

आखिर में, हम आखिरी डेटा क्यूब को फ़्लैट करके, क्लासिफ़िकेशन हेड जोड़ते हैं. इसके बाद, इसे डेंस और सॉफ़्टमैक्स ऐक्टिवेटेड लेयर में फ़ीड किया जाता है. सामान्य तौर पर, कनवोल्यूशनल क्लासिफ़ायर ऐसा दिखता है:

इलस्ट्रेशन: कनवोल्यूशनल और सॉफ़्टमैक्स लेयर का इस्तेमाल करने वाला इमेज क्लासिफ़ायर. इसमें 3x3 और 1x1 फ़िल्टर का इस्तेमाल किया जाता है. maxpool लेयर, 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. आपका कस्टम कॉन्वनेट

खुद करके सीखना

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

Keras_Flowers_TPU (playground).ipynb

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

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

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

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

समाधान

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

Keras_Flowers_TPU (solution).ipynb

हमने क्या-क्या बताया

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

कृपया इस चेकलिस्ट को एक बार ध्यान से देख लें.

7. बधाई हो!

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

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

TPU का इस्तेमाल

TPU और GPU, Cloud AI Platform पर उपलब्ध हैं:

डीप लर्निंग वीएम पर
AI Platform Notebooks में
AI Platform Training की नौकरियों में

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

Martin Görner ID small.jpg
लेखक: मार्टिन गर्नर
Twitter: @martin_gorner

tensorflow logo.jpg
www.tensorflow.org