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

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

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

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

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

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

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

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

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

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

कम शब्दों में

इलस्ट्रेशन: एक कनवोल्यूशनल "मॉड्यूल". इस समय सबसे अच्छा क्या है ? मैक्स-पूल लेयर के बाद 1x1 कनवोल्यूशनल लेयर या लेयर का कोई अन्य कॉम्बिनेशन ? इन सभी को आज़माएं, नतीजों को एक साथ जोड़ें, और नेटवर्क को फ़ैसला लेने दें. दाईं ओर: ऐसे मॉड्यूल का इस्तेमाल करने वाला " inception" कनवोल्यूशनल आर्किटेक्चर.

Keras में, ऐसे मॉडल बनाने के लिए "फ़ंक्शनल" मॉडल स्टाइल का इस्तेमाल करना होता है जिनमें डेटा फ़्लो को ब्रांच इन और आउट किया जा सकता है. उदाहरण के लिए:

l = tf.keras.layers # syntax shortcut

y = l.Conv2D(filters=32, kernel_size=3, padding='same',
             activation='relu', input_shape=[192, 192, 3])(x) # x=input image

# module start: branch out
y1 = l.Conv2D(filters=32, kernel_size=1, padding='same', activation='relu')(y)
y3 = l.Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')(y)
y = l.concatenate([y1, y3]) # output now has 64 channels
# module end: concatenation

# many more layers ...

# Create the model by specifying the input and output tensors.
# Keras layers track their connections automatically so that's all that's needed.
z = l.Dense(5, activation='softmax')(y)
model = tf.keras.Model(x, z)

अन्य घटिया तरीके

छोटे 3x3 फ़िल्टर

इस इलस्ट्रेशन में, लगातार दो 3x3 फ़िल्टर का नतीजा दिखाया गया है. यह पता लगाने की कोशिश करें कि किन डेटा पॉइंट से नतीजा मिला है: ये दो लगातार 3x3 फ़िल्टर, 5x5 क्षेत्र के कुछ कॉम्बिनेशन का हिसाब लगाते हैं. यह ठीक वैसा कॉम्बिनेशन नहीं है जैसा कि 5x5 फ़िल्टर से कैलकुलेट किया जाता है. हालांकि, इसे आज़माया जा सकता है, क्योंकि लगातार दो 3x3 फ़िल्टर, एक 5x5 फ़िल्टर से ज़्यादा किफ़ायती होते हैं.

1x1 कनवोल्यूशन क्या है ?

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

7. Squeezenet

इन आइडिया को एक साथ इस्तेमाल करने का आसान तरीका, "Squeezenet" पेपर में दिखाया गया है. लेखकों ने एक बहुत ही सामान्य कनवोल्यूशनल मॉड्यूल डिज़ाइन का सुझाव दिया है. इसमें सिर्फ़ 1x1 और 3x3 कनवोल्यूशनल लेयर का इस्तेमाल किया गया है.

इलस्ट्रेशन: "फ़ायर मॉड्यूल" पर आधारित स्क्वीज़नेट आर्किटेक्चर. ये एक के बाद एक 1x1 लेयर का इस्तेमाल करते हैं. ये लेयर, वर्टिकल डाइमेंशन में आने वाले डेटा को "स्क्वीज़" करती हैं. इसके बाद, दो पैरलल 1x1 और 3x3 कनवोल्यूशनल लेयर होती हैं, जो डेटा की डेप्थ को फिर से "बढ़ाती" हैं.

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

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

Keras_Flowers_TPU (playground).ipynb

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

इस अभ्यास के लिए, squeezenet मॉड्यूल के लिए हेल्पर फ़ंक्शन को परिभाषित करना मददगार होगा:

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

फ़ायर मॉड्यूल में, "squeeze" पैरामीटर की वैल्यू, "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

इसके बाद, इसका इस्तेमाल अपने फ़ाइनल डेटा ट्रांसफ़ॉर्मेशन (सेल "training and validation datasets", फ़ंक्शन "get_batched_dataset") में करें:

dataset = dataset.repeat() # existing line
# insert this
if augment_data:
  dataset = dataset.map(data_augment, num_parallel_calls=AUTO)
dataset = dataset.shuffle(2048) # existing line

डेटा को बेहतर बनाने की सुविधा को वैकल्पिक बनाना न भूलें. साथ ही, यह पक्का करने के लिए ज़रूरी कोड जोड़ें कि सिर्फ़ ट्रेनिंग डेटासेट को बेहतर बनाया गया हो. पुष्टि करने के लिए इस्तेमाल किए जाने वाले डेटासेट को बढ़ाने का कोई मतलब नहीं है.

अब 35 इपॉक में 80% सटीकता हासिल की जा सकती है.

समाधान

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

Keras_Flowers_TPU_squeezenet.ipynb

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

🤔 Keras "फ़ंक्शनल स्टाइल" मॉडल
🤓 Squeezenet आर्किटेक्चर
🤓 tf.data.datset की मदद से नया डेटा जनरेट करना और मौजूदा डेटा में बदलाव करके ज़्यादा डेटा जनरेट करना

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

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

सेपरेबल कन्वलूशन

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

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

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

सेपरेबल कनवोल्यूशन का इस्तेमाल, हाल ही के ज़्यादातर कनवोल्यूशनल नेटवर्क आर्किटेक्चर में किया जाता है. जैसे, MobileNetV2, Xception, EfficientNet. वैसे, आपने ट्रांसफ़र लर्निंग के लिए MobileNetV2 का इस्तेमाल किया था.

ये सामान्य कनवोल्यूशन से सस्ते होते हैं और प्रैक्टिस में उतने ही असरदार पाए गए हैं. ऊपर दिए गए उदाहरण के लिए, यहां वज़न की गिनती दी गई है:

कन्वलूशनल लेयर: 4 x 4 x 3 x 5 = 240

सेपरेबल कनवोल्यूशनल लेयर: 4 x 4 x 3 + 3 x 5 = 48 + 15 = 63

हमारा सुझाव है कि पाठक, इस बात का पता लगाएं कि कनवोल्यूशनल लेयर के हर स्टाइल को एक ही तरीके से लागू करने के लिए, कितनी बार गुणा करने की ज़रूरत होती है. सेपरेबल कनवोल्यूशन, छोटे होते हैं और कंप्यूटेशनल तौर पर ज़्यादा असरदार होते हैं.

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

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

Keras Flowers transfer learning (playground).ipynb

लक्ष्य: 95% से ज़्यादा सटीक जवाब देना (हां, वाकई ऐसा हो सकता है!)

यह आखिरी कसरत है. इसलिए, इसमें थोड़ा ज़्यादा कोड और डेटा साइंस से जुड़ा काम करना होगा.

फ़ाइन-ट्यूनिंग के बारे में ज़्यादा जानकारी

Xception, tf.keras.application.* में पहले से ट्रेन किए गए स्टैंडर्ड मॉडल में उपलब्ध है इस बार, सभी वज़न को ट्रेनिंग के लिए उपलब्ध कराना न भूलें.

pretrained_model = tf.keras.applications.Xception(input_shape=[*IMAGE_SIZE, 3],
                                                  include_top=False)
pretrained_model.trainable = True

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

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

Keras में, लर्निंग रेट को एक कॉलबैक के ज़रिए तय किया जाता है. इसमें हर युग के लिए सही लर्निंग रेट का हिसाब लगाया जा सकता है. Keras, हर युग के लिए ऑप्टिमाइज़र को सही लर्निंग रेट पास करेगा.

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

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

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

समाधान

07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

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

🤔 डेप्थ-सेपरेबल कनवोल्यूशन
🤓 लर्निंग रेट के शेड्यूल
😈 पहले से ट्रेन किए गए मॉडल को फ़ाइन-ट्यून करना.

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

9. बधाई हो!

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

टीपीयू की स्पीड वाली डेटा पाइपलाइन: tf.data.Dataset और TFRecords
ट्रांसफ़र लर्निंग की मदद से, अपना पहला Keras मॉडल बनाना
Keras और TPU के साथ कनवोल्यूशनल न्यूरल नेटवर्क
[THIS LAB] 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