1. खास जानकारी
इस लैब में, आप फूलों की पहचान करने वाले न्यूरल नेटवर्क मॉडल में कॉन्वलूशनल लेयर जोड़ने का तरीका सीखेंगे. इस बार, आपको नए सिरे से मॉडल बनाने का मौका मिलेगा. इसके अलावा, TPU की ताकत का इस्तेमाल करके, उसे कुछ ही सेकंड में ट्रेनिंग दी जाएगी और उसके बाद फिर से उसका डिज़ाइन तैयार किया जाएगा.
इस लैब में, कॉन्वलूशनल न्यूरल नेटवर्क के बारे में ज़रूरी सैद्धांतिक व्याख्याएं शामिल हैं. साथ ही, डीप लर्निंग के बारे में सीखने वाले डेवलपर के लिए, यह लैब एक अच्छा शुरुआती पॉइंट है.
यह लैब, "TPU पर Keras" सीरीज़ का तीसरा हिस्सा है. नीचे दिए गए क्रम में या अलग से ऐसा किया जा सकता है.
- TPU-स्पीड डेटा पाइपलाइन: tf.data.Dataset और TFRecords
- ट्रांसफ़र लर्निंग की मदद से, अपना पहला Keras मॉडल बनाना
- [THIS LAB] Keras और TPU के साथ कॉन्वलूशनल न्यूरल नेटवर्क
- Keras और TPU के साथ आधुनिक कॉन्वेंट, squeezenet, Xception
आपको क्या सीखने को मिलेगा
- Keras क्रमिक मॉडल का इस्तेमाल करके कनवलूशनल इमेज क्लासिफ़ायर बनाने के लिए.
- TPU पर अपने Keras मॉडल को ट्रेनिंग देने के लिए
- कॉन्वलूशनल लेयर के अच्छे विकल्प के साथ, अपने मॉडल को बेहतर बनाने के लिए.
सुझाव, राय या शिकायत
अगर आपको इस कोड लैब में कुछ गड़बड़ी दिखती है, तो कृपया हमें बताएं. GitHub की समस्याओं [ सुझाव/राय देने या शिकायत करने के लिए लिंक] के ज़रिए सुझाव, शिकायत या राय दी जा सकती है.
2. Google Colaboratory क्विक स्टार्ट
यह लैब, Google Collaboratory का इस्तेमाल करता है और आपको अपनी ओर से किसी सेटअप की ज़रूरत नहीं होती. Colaboratory, शिक्षा के मकसद से बनाया गया एक ऑनलाइन नोटबुक प्लैटफ़ॉर्म है. इसमें सीपीयू, जीपीयू, और TPU की मुफ़्त ट्रेनिंग दी जाती है.
Colaboratory के बारे में जानने के लिए, इस सैंपल नोटबुक को खोला जा सकता है और कुछ सेल को चलाया जा सकता है.
कोई TPU बैकएंड चुनें
Colab मेन्यू में, रनटाइम > रनटाइम का टाइप बदलें को चुनें. इसके बाद, TPU चुनें. इस कोड लैब में, आपको हार्डवेयर की मदद से तेज़ी से ट्रेनिंग देने वाली सुविधा के लिए, बेहतर TPU (टेंसर प्रोसेसिंग यूनिट) का इस्तेमाल करना होगा. पहली बार एक्ज़ीक्यूशन करने पर, रनटाइम से कनेक्शन अपने-आप हो जाएगा. इसके अलावा, सबसे ऊपर दाएं कोने में मौजूद "कनेक्ट करें" बटन का इस्तेमाल भी किया जा सकता है.
नोटबुक चलाना
सेल पर क्लिक करके और Shift-ENTER का इस्तेमाल करके एक-एक करके सेल एक्ज़ीक्यूट करें. रनटाइम > सभी चलाएं में जाकर भी पूरी नोटबुक को चलाया जा सकता है.
विषय सूची
सभी नोटबुक में विषय सूची होती है. इसे खोलने के लिए, बाईं ओर मौजूद काले ऐरो का इस्तेमाल करें.
छिपी हुई सेल
कुछ सेल में सिर्फ़ उनका टाइटल दिखेगा. यह सुविधा, Colab की नोटबुक में ही उपलब्ध है. अंदर का कोड देखने के लिए उन पर दो बार क्लिक करें, लेकिन आम तौर पर यह बहुत दिलचस्प नहीं होता. आम तौर पर, सहायता या विज़ुअलाइज़ेशन फ़ंक्शन. इन सेल में मौजूद फ़ंक्शन तय करने के लिए, आपको इन्हें फिर से चलाना होगा.
पुष्टि करना
Colab, Google Cloud Storage की आपकी निजी बकेट को ऐक्सेस कर सकता है. इसके लिए, ज़रूरी है कि आपने अनुमति वाले किसी खाते की मदद से पुष्टि की हो. ऊपर दिया गया कोड स्निपेट, पुष्टि करने की प्रोसेस को ट्रिगर करेगा.
3. [INFO] टेन्सर प्रोसेसिंग यूनिट (टीपीयू) क्या हैं ?
कम शब्दों में
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 कॉलम को गुणा करें और देखें कि यह असल में किसी इमेज की सभी पिक्सल वैल्यू का वेटेड योग कर रहा है या नहीं. कॉन्वोल्यूशनल लेयर को मैट्रिक्स के गुणन के तौर पर भी दिखाया जा सकता है. हालांकि, यह थोड़ा मुश्किल है ( पहले सेक्शन में यहां इसकी जानकारी दी गई है).
हार्डवेयर
MXU और VPU
TPU v2 कोर, मैट्रिक्स मल्टीप्लाई यूनिट (एमएक्सयू) से बना होता है, जो मैट्रिक्स मल्टीप्लिकेशन और वेक्टर प्रोसेसिंग यूनिट (वीपीयू) को अन्य सभी कामों के लिए इस्तेमाल करता है. जैसे, ऐक्टिवेशन, सॉफ़्टमैक्स वगैरह. यह वीपीयू, float32 और int32 कंप्यूटेशन को हैंडल करता है. दूसरी ओर, MXU मिश्रित सटीक 16-32 बिट फ़्लोटिंग पॉइंट फ़ॉर्मैट में काम करता है.
मिक्स्ड प्रिसीज़न फ़्लोटिंग पॉइंट और bfloat16
MXU, bfloat16 इनपुट और float32 आउटपुट का इस्तेमाल करके, मैट्रिक्स के गुणन की गणना करता है. बीच के लेवल पर इकट्ठा किए जाने वाले डेटा को float32 सटीक तरीके से प्रोसेस किया जाता है.
न्यूरल नेटवर्क ट्रेनिंग में, फ़्लोटिंग पॉइंट के कम सटीक होने की वजह से आने वाले शोर का कोई असर नहीं होता. ऐसे मामले भी हैं जहां शोर, ऑप्टिमाइज़र को बेहतर बनाने में मदद करता है. आम तौर पर, 16-बिट फ़्लोटिंग पॉइंट प्रिसिज़न का इस्तेमाल कंप्यूटेशन की रफ़्तार बढ़ाने के लिए किया जाता है. हालांकि, float16 और float32 फ़ॉर्मैट की रेंज काफ़ी अलग हैं. float32 से float16 तक की शुद्धता को कम करने से, आम तौर पर ओवर और अंडरफ़्लो बनता है. समस्याओं के समाधान मौजूद हैं, लेकिन float16 को काम करने के लिए आम तौर पर ज़्यादा काम करना पड़ता है.
इसलिए, Google ने टीपीयू में bfloat16 फ़ॉर्मैट को पेश किया. bfloat16, काटे गए float32 फ़ॉर्मैट का एक वर्शन है. इसमें एक्सपोनेंट बिट और रेंज, float32 फ़ॉर्मैट की तरह ही होती है. साथ ही, TPU, मैट्रिक्स के गुणा को bfloat16 इनपुट के साथ मिक्स्ड प्रिसीज़न में कैलकुलेट करते हैं, लेकिन float32 आउटपुट देते हैं. इसका मतलब है कि आम तौर पर, कम सटीक होने पर परफ़ॉर्मेंस में होने वाले फ़ायदे पाने के लिए, कोड में कोई बदलाव करना ज़रूरी नहीं है.
सिस्टोलिक अरे
MXU, कथित "सिस्टोलिक अरे" आर्किटेक्चर का इस्तेमाल करके, हार्डवेयर में मैट्रिक्स गुणन को लागू करता है. इसमें डेटा एलिमेंट, हार्डवेयर कंप्यूटेशन यूनिट के कलेक्शन से होकर गुज़रते हैं. (चिकित्सा में, "सिस्टोलिक" का मतलब दिल के संकुचन और खून के प्रवाह से है, यहां डेटा के प्रवाह तक.)
मैट्रिक्स के गुणा करने का बुनियादी एलिमेंट, एक मैट्रिक्स की लाइन और दूसरी मैट्रिक्स के कॉलम के बीच का डॉट प्रॉडक्ट होता है. इस सेक्शन में सबसे ऊपर दी गई इमेज देखें. किसी मैट्रिक्स गुणा Y=X*W के लिए, नतीजे का एक एलिमेंट यह होगा:
Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]
जीपीयू पर, इस डॉट प्रॉडक्ट को जीपीयू "कोर" में प्रोग्राम किया जाएगा और फिर नतीजे के तौर पर दिखने वाले मैट्रिक्स की हर वैल्यू को एक साथ आज़माने और कंप्यूट करने के लिए, जितने चाहें उतने "कोर" को एक्ज़ीक्यूट किया जाएगा. अगर नतीजा देने वाला मैट्रिक्स 128x128 बड़ा है, तो इसके लिए 128x128=16K "कोर" उपलब्ध होने चाहिए, जो आम तौर पर मुमकिन नहीं है. सबसे बड़े जीपीयू में करीब 4,000 कोर होते हैं. वहीं दूसरी ओर, TPU, MXU में कंप्यूट यूनिट के लिए कम से कम हार्डवेयर का इस्तेमाल करता है. इसमें सिर्फ़ bfloat16 x bfloat16 => float32 मल्टी-अक्युमिलेटर हैं, कुछ और नहीं. ये इतने छोटे होते हैं कि एक TPU, 128x128 MXU में 16K को लागू कर सकता है और एक बार में इस मैट्रिक्स गुणन को प्रोसेस कर सकता है.
इलस्ट्रेशन: MXU सिस्टोलिक अरे. कंप्यूट एलिमेंट, मल्टीप्लाई-ऐक्यूमुलेटर होते हैं. एक मैट्रिक की वैल्यू, ऐरे (लाल बिंदु) में लोड की जाती हैं. अन्य मैट्रिक्स की वैल्यू, कलेक्शन (स्लेटी बिंदु) से होकर गुज़रती हैं. वर्टिकल लाइन, वैल्यू को ऊपर की ओर भेजती हैं. हॉरिज़ॉन्टल लाइनें, आंशिक योग को लागू करती हैं. इसे उपयोगकर्ता को कसरत के तौर पर छोड़ दिया जाता है, ताकि यह पुष्टि की जा सके कि जैसे-जैसे डेटा अरे से गुज़रेगा वैसे-वैसे आपको दाईं ओर से मिले मैट्रिक्स गुणा का नतीजा मिलेगा.
इसके अलावा, जब किसी एमएक्सयू में डॉट प्रॉडक्ट का हिसाब लगाया जा रहा होता है, तब बीच में जोड़ने के लिए इस्तेमाल होने वाले वैल्यू, आस-पास की कंप्यूट यूनिट के बीच आसानी से फ़्लो होती हैं. उन्हें मेमोरी या रजिस्टर फ़ाइल में भी स्टोर करने या वापस लाने की ज़रूरत नहीं होती. इसका नतीजा यह है कि मैट्रिक्स के गुणा का हिसाब लगाते समय, TPU सिस्ट्रॉलिक ऐरे आर्किटेक्चर में डेंसिटी और पावर का फ़ायदा मिलता है. साथ ही, यह जीपीयू की तुलना में तेज़ी से काम करता है.
क्लाउड टीपीयू
Google Cloud Platform पर "Cloud TPU v2" का अनुरोध करने पर, आपको एक वर्चुअल मशीन (VM) मिलती है. इसमें पीसीआई से जुड़ा TPU बोर्ड होता है. TPU बोर्ड में, ड्यूअल-कोर TPU चिप होते हैं. हर TPU कोर में एक VPU (वेक्टर प्रोसेसिंग यूनिट) और 128x128 MXU (मैट्रिक्स गुणा यूनिट) मौजूद होता है. इसके बाद, आम तौर पर इस "Cloud TPU" को नेटवर्क के ज़रिए उस वीएम से कनेक्ट किया जाता है जिसने इसका अनुरोध किया है. इसलिए, पूरी तस्वीर कुछ ऐसी दिखती है:
इमेज: नेटवर्क से जुड़े "Cloud TPU" ऐक्सेलरेटर वाला आपका वीएम. "Cloud TPU", एक वीएम से बना है. इसमें पीसीआई से जुड़ा TPU बोर्ड है, जिस पर चार ड्यूअल-कोर TPU चिप हैं.
TPU पॉड
Google के डेटा सेंटर में, टीपीयू को हाई परफ़ॉर्मेंस कंप्यूटिंग (एचपीसी) इंटरकनेक्ट से जोड़ा जाता है. इससे, उन्हें एक बहुत बड़े ऐक्सेलरेटर के तौर पर देखा जा सकता है. Google उन्हें पॉड कहता है. इनमें 512 TPU v2 कोर या 2048 TPU v3 कोर शामिल हो सकते हैं.
इमेज: TPU v3 पॉड. एचपीसी इंटरकनेक्ट के ज़रिए कनेक्ट किए गए टीपीयू बोर्ड और रैक.
ट्रेनिंग के दौरान, सभी-कम करने वाले एल्गोरिदम का इस्तेमाल करके, टीपीयू कोर के बीच ग्रेडिएंट का आदान-प्रदान किया जाता है ( सभी-कम करने वाले एल्गोरिदम के बारे में यहां अच्छी जानकारी). जिस मॉडल को ट्रेन किया जा रहा है वह बड़े बैच साइज़ पर ट्रेनिंग करके, हार्डवेयर का फ़ायदा ले सकता है.
इलस्ट्रेशन: Google TPU के 2-D टॉरॉइडल मेश एचपीसी नेटवर्क पर, ऑल-रिड्यूस एल्गोरिदम का इस्तेमाल करके, ट्रेनिंग के दौरान ग्रेडिएंट को सिंक करना.
सॉफ़्टवेयर
बड़े बैच साइज़ के लिए ट्रेनिंग
टीपीयू के लिए, हर टीपीयू कोर के लिए 128 डेटा आइटम का बैच साइज़ आदर्श होता है. हालांकि, हर टीपीयू कोर के लिए आठ डेटा आइटम से भी हार्डवेयर का अच्छा इस्तेमाल किया जा सकता है. याद रखें कि एक Cloud TPU में 8 कोर होते हैं.
इस कोड लैब में, हम Keras API का इस्तेमाल करेंगे. Keras में, आपके तय किए गए बैच का साइज़, पूरे टीपीयू के लिए ग्लोबल बैच साइज़ होता है. आपके बैच अपने-आप आठ में बंट जाएंगे और TPU के 8 कोर पर चलते रहेंगे.
परफ़ॉर्मेंस से जुड़ी अन्य सलाह के लिए, TPU की परफ़ॉर्मेंस गाइड देखें. बहुत बड़े बैच साइज़ के लिए, कुछ मॉडल में खास देखभाल की ज़रूरत हो सकती है. ज़्यादा जानकारी के लिए, LARSOptimizer पर जाएं.
हुड के बारे में: एक्सएलए
Tensorflow प्रोग्राम, कंप्यूटेशन के ग्राफ़ को तय करते हैं. टीपीयू, सीधे Python कोड नहीं चलाता. यह आपके Tensorflow प्रोग्राम से तय किए गए कंप्यूटेशन ग्राफ़ को चलाता है. XLA (accelerated Linear Algebra compiler) नाम का कंपाइलर, कंप्यूटेशन नोड के Tensorflow ग्राफ़ को TPU मशीन कोड में बदलता है. यह कंपाइलर आपके कोड और मेमोरी लेआउट पर कई बेहतर ऑप्टिमाइज़ेशन भी करता है. TPU पर काम भेजने पर, कंपाइलेशन अपने-आप होता है. आपको अपनी बिल्ड चेन में XLA को साफ़ तौर पर शामिल करने की ज़रूरत नहीं है.
इलस्ट्रेशन: TPU पर चलाने के लिए, आपके Tensorflow प्रोग्राम के तय किए गए कंप्यूटेशन ग्राफ़ को सबसे पहले XLA (Accelerated लीनियर Algebra कंपाइलर) के रूप में बदला जाता है. इसके बाद, XLA की मदद से TPU मशीन कोड में उसे कंपाइल किया जाता है.
Keras में TPU इस्तेमाल करना
Tensorflow 2.1 के बाद, TPUs का इस्तेमाल 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 एनवायरमेंट बनाया गया है उस पर TPU_NAME एनवायरमेंट सेट करें या इन पैरामीटर के साथTPUClusterResolverको कॉल करें:TPUClusterResolver(tp_uname, zone, project)TPUStrategyवह हिस्सा है जो डिस्ट्रिब्यूशन और "all-reduce" ग्रेडिएंट सिंकिंग एल्गोरिदम को लागू करता है.- रणनीति को एक स्कोप की मदद से लागू किया जाता है. मॉडल को 'रणनीति के दायरे' में तय किया जाना चाहिए.
tpu_model.fitफ़ंक्शन, TPU ट्रेनिंग के लिए इनपुट के तौर पर tf.data.Dataset ऑब्जेक्ट का इस्तेमाल करता है.
TPU पोर्टिंग से जुड़े सामान्य टास्क
- Tensorflow मॉडल में डेटा लोड करने के कई तरीके हैं. हालांकि, टीपीयू के लिए
tf.data.Datasetएपीआई का इस्तेमाल करना ज़रूरी है. - TPU बहुत तेज़ी से काम करते हैं. जब इन पर चलाया जाता है, तो डेटा का डेटा घुलने-मिलने में मुश्किल हो जाता है. TPU की परफ़ॉर्मेंस से जुड़ी गाइड में, डेटा की रुकावटों का पता लगाने और परफ़ॉर्मेंस से जुड़ी अन्य सलाह पाने के लिए टूल दिए गए हैं.
- int8 या int16 नंबर को int32 के तौर पर माना जाता है. टीपीयू में, 32 बिट से कम पर काम करने वाला इंटिजर हार्डवेयर नहीं होता.
- Tensorflow के कुछ ऑपरेशन काम नहीं करते. सूची यहां दी गई है. अच्छी बात यह है कि यह पाबंदी सिर्फ़ ट्रेनिंग कोड, जैसे कि आपके मॉडल के आगे और पीछे वाले पास पर लागू होती है. अब भी अपनी डेटा इनपुट पाइपलाइन में सभी Tensorflow ऑपरेशन का इस्तेमाल किया जा सकता है, क्योंकि यह सीपीयू पर लागू होगा.
tf.py_func, TPU पर काम नहीं करता.
4. [जानकारी] न्यूरल नेटवर्क क्लासिफ़ायर के बारे में बुनियादी जानकारी
कम शब्दों में
अगर अगले पैराग्राफ़ में बोल्ड में लिखे गए सभी शब्द आपको पहले से ही पता हैं, तो अगले एक्सरसाइज़ पर जाएं. अगर आपने डीप लर्निंग की शुरुआत अभी-अभी की है, तो आपका स्वागत है. कृपया आगे पढ़ें.
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 तक जोड़ा जा सके और उन्हें प्रायिकता के रूप में समझा जा सके.
क्रॉस-एन्ट्रापी लॉस
अब जब हमारा न्यूरल नेटवर्क इनपुट इमेज से अनुमान लगाता है, तो हमें यह मापना होता है कि वे कितने अच्छे हैं, यानी कि नेटवर्क हमें जो जानकारी देता है और सही जवाबों के बीच की दूरी, उन्हें अक्सर "लेबल" कहा जाता है. याद रखें कि डेटासेट में मौजूद सभी इमेज के लिए, हमारे पास सही लेबल हैं.
किसी भी दूरी से काम किया जा सकता है, लेकिन कैटगरी तय करने में आने वाली समस्याओं के लिए "क्रॉस-एंट्रॉपी डिस्टेंस" सबसे असरदार तरीका है. हम इसे गड़बड़ी या "नुकसान" फ़ंक्शन कहेंगे:
ग्रेडिएंट डिसेंट
न्यूरल नेटवर्क को "ट्रेनिंग" देने का मतलब है, ट्रेनिंग इमेज और लेबल का इस्तेमाल करके वेट और बायस में बदलाव करना, ताकि क्रॉस-एन्ट्रोपी लॉस फ़ंक्शन को कम किया जा सके. यह सुविधा इस तरह से काम करती है.
क्रॉस-एन्ट्रोपी, ट्रेनिंग इमेज और उसकी क्लास के पिक्सल, वेट, और बायस का फ़ंक्शन है.
अगर हम सभी वेट और सभी पूर्वाग्रहों के सापेक्ष क्रॉस-एंट्रॉपी के आंशिक डेरिवेटिव का हिसाब लगाते हैं, तो हमें दी गई इमेज, लेबल, और भार और पक्षपात के मौजूदा मान के लिए एक "ग्रेडिएंट" मिलता है. याद रखें कि हमारे पास लाखों वज़न और पूर्वाग्रह हो सकते हैं, इसलिए ग्रेडिएंट की गणना करना बहुत बड़ा काम है. अच्छी बात यह है कि Tensorflow यह काम हमारे लिए करता है. ग्रेडिएंट की गणितीय विशेषता यह है कि यह "ऊपर" को पॉइंट करता है. चूंकि हम वहां जाना चाहते हैं जहां क्रॉस-एंट्रॉपी कम है, इसलिए हम इसके विपरीत दिशा में जाते हैं. हम ग्रेडिएंट के एक अंश के अनुसार वज़न और पूर्वाग्रह अपडेट करते हैं. इसके बाद, हम ट्रेनिंग लूप में ट्रेनिंग इमेज और लेबल के अगले बैच का इस्तेमाल करके, यही काम बार-बार करते हैं. उम्मीद है कि यह उस जगह पर पहुंच जाएगा जहां क्रॉस-एन्ट्रापी कम से कम होगी. हालांकि, इस बात की कोई गारंटी नहीं है कि यह कम से कम वैल्यू यूनीक होगी.
मिनी बैचिंग और मोमेंटम
आप सिर्फ़ एक उदाहरण इमेज पर अपने ग्रेडिएंट का हिसाब लगा सकते हैं और महत्व और पक्षपात को तुरंत अपडेट कर सकते हैं, लेकिन उदाहरण के लिए, 128 इमेज के बैच पर ऐसा करने से ग्रेडिएंट मिलता है, जो अलग-अलग उदाहरण वाली इमेज के ज़रिए लागू किए गए कंस्ट्रेंट को बेहतर तरीके से दिखाता है और इससे समाधान ज़्यादा तेज़ी से जुड़ सकता है. मिनी-बैच के साइज़ में बदलाव किया जा सकता है.
इस तकनीक को "स्टोकेस्टिक ग्रेडिएंट डिसेंट" भी कहा जाता है. इसका एक और व्यावहारिक फ़ायदा है: बैच के साथ काम करने का मतलब है बड़े मैट्रिक्स के साथ काम करना. आम तौर पर, जीपीयू और टीपीयू पर इन्हें ऑप्टिमाइज़ करना आसान होता है.
हालांकि, कन्वर्ज़न अब भी थोड़ा गड़बड़ा हो सकता है और अगर ग्रेडिएंट वेक्टर में सभी वैल्यू शून्य हैं, तो यह रुक भी सकता है. क्या इसका मतलब है कि हमें कम से कम वैल्यू मिल गई है? हमेशा नहीं. ग्रेडिएंट कॉम्पोनेंट, कम से कम या ज़्यादा से ज़्यादा शून्य हो सकता है. लाखों तत्वों वाले ग्रेडिएंट वेक्टर के साथ, अगर वे सभी शून्य हैं, तो इस बात की संभावना है कि हर शून्य एक न्यूनतम बिंदु से मेल खाता है और उनमें से कोई भी अधिकतम बिंदु से नहीं जुड़ा है. कई डाइमेंशन वाले स्पेस में, सैडल पॉइंट काफ़ी आम होते हैं और हम उन पर रुकना नहीं चाहते.
इलस्ट्रेशन: सैडल पॉइंट. ग्रेडिएंट 0 है लेकिन यह सभी दिशाओं में कम से कम नहीं है. (इमेज एट्रिब्यूशन Wikimedia: by Nicoguro - खुद का काम, CC BY 3.0)
इसका समाधान यह है कि ऑप्टिमाइज़ेशन एल्गोरिदम में कुछ मोमेंटम जोड़ा जाए, ताकि वह बिना रुके सैडल पॉइंट को पार कर सके.
शब्दावली
बैच या मिनी-बैच: ट्रेनिंग, हमेशा ट्रेनिंग डेटा और लेबल के बैच पर की जाती है. ऐसा करने से, एल्गोरिदम को बेहतर बनाने में मदद मिलती है. आम तौर पर, "बैच" डाइमेंशन, डेटा टेंसर का पहला डाइमेंशन होता है. उदाहरण के लिए, आकार के टेंसर [100, 192, 192, 3] में 192x192 पिक्सल की 100 इमेज होती हैं, जिनमें हर पिक्सल (RGB) में तीन वैल्यू होती हैं.
क्रॉस-एन्ट्रोपी लॉस: यह एक खास लॉस फ़ंक्शन है, जिसका इस्तेमाल अक्सर क्लासिफ़ायर में किया जाता है.
डेंस लेयर: यह न्यूरॉन की एक ऐसी लेयर होती है जिसमें हर न्यूरॉन, पिछली लेयर के सभी न्यूरॉन से जुड़ा होता है.
features: न्यूरल नेटवर्क के इनपुट को कभी-कभी "सुविधाएं" कहा जाता है. किसी डेटासेट के किन हिस्सों (या हिस्सों के कॉम्बिनेशन) को किसी न्यूरल नेटवर्क में डालकर, अच्छे अनुमान पाने की कला को "फ़ीचर इंजीनियरिंग" कहा जाता है.
लेबल: सुपरवाइज़्ड क्लासिफ़िकेशन की समस्या में, "क्लास" या सही जवाबों का दूसरा नाम
लर्निंग रेट: ग्रेडिएंट का वह हिस्सा जिससे ट्रेनिंग लूप के हर दोहराव पर वेट और बायस अपडेट होते हैं.
लॉगिट: ऐक्टिवेशन फ़ंक्शन लागू करने से पहले, न्यूरॉन की लेयर के आउटपुट को "लॉगिट" कहा जाता है. यह शब्द, "लॉजिस्टिक फ़ंक्शन" से लिया गया है. इसे "सिगमोइड फ़ंक्शन" भी कहा जाता है. यह सबसे लोकप्रिय ऐक्टिवेशन फ़ंक्शन था. "लॉजिस्टिक फ़ंक्शन से पहले न्यूरॉन आउटपुट" को छोटा करके "लॉगिट" कर दिया गया.
loss: गड़बड़ी का फ़ंक्शन, जो सही जवाबों के साथ न्यूरल नेटवर्क के आउटपुट की तुलना करता है
न्यूरॉन: यह अपने इनपुट के भारित योग का आकलन करता है, पूर्वाग्रह जोड़ता है और ऐक्टिवेशन फ़ंक्शन के ज़रिए नतीजे को फ़ीड करता है.
वन-हॉट एन्कोडिंग: 5 में से 3 क्लास को 5 एलिमेंट के वेक्टर के तौर पर एन्कोड किया जाता है. इसमें तीसरे एलिमेंट को छोड़कर, बाकी सभी शून्य होते हैं, यानी कि 1.
relu: सुधारी गई लीनियर यूनिट. न्यूरॉन के लिए एक लोकप्रिय ऐक्टिवेशन फ़ंक्शन.
sigmoid: ऐक्टिवेशन का एक और ऐसा फ़ंक्शन जो पहले लोकप्रिय हुआ था और खास मामलों में अब भी काम का है.
softmax: यह एक खास ऐक्टिवेशन फ़ंक्शन है, जो वेक्टर पर काम करता है. यह सबसे बड़े कॉम्पोनेंट और अन्य सभी कॉम्पोनेंट के बीच के अंतर को बढ़ाता है. साथ ही, वेक्टर को सामान्य बनाकर उसका योग 1 करता है, ताकि इसे संभावनाओं के वेक्टर के तौर पर समझा जा सके. इसका इस्तेमाल क्लासिफ़ायर में आखिरी चरण के तौर पर किया जाता है.
टेंसर: "टेंसर", मैट्रिक्स की तरह ही होता है. हालांकि, इसमें डाइमेंशन की संख्या ज़रूरी नहीं होती. 1-डाइमेंशन वाला टेंसर एक वेक्टर होता है. दो डाइमेंशन वाला टेंसर एक मैट्रिक्स होता है. इसके बाद, आपके पास तीन, चार, पांच या उससे ज़्यादा डाइमेंशन वाले टेंसर हो सकते हैं.
5. [नई जानकारी] कॉन्वॉल्यूशन न्यूरल नेटवर्क
कम शब्दों में
अगर अगले पैराग्राफ़ में बोल्ड में दिए गए सभी शब्दों के बारे में आपको पहले से पता है, तो अगले अभ्यास पर जाएं. अगर आप कॉन्वलूशनल न्यूरल नेटवर्क से अभी शुरुआत कर रहे हैं, तो कृपया आगे पढ़ें.
इलस्ट्रेशन: किसी इमेज को फ़िल्टर करने के लिए, हर फ़िल्टर का क्रम में 4x4x3=48 वज़न दिया गया है.
Keras में, एक आसान कॉन्वोल्यूशनल न्यूरल नेटवर्क इस तरह दिखता है:
model = tf.keras.Sequential([
# input: images of size 192x192x3 pixels (the three stands for RGB channels)
tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
tf.keras.layers.Flatten(),
# classifying into 5 categories
tf.keras.layers.Dense(5, activation='softmax')
])
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy'])
कॉन्वलूशनल न्यूरल नेट्स 101
कॉन्वलूशनल नेटवर्क की एक लेयर में, एक "न्यूरॉन" इमेज के एक छोटे से क्षेत्र में इसके ठीक ऊपर पिक्सल का वेटेड योग करता है. यह पूर्वाग्रह जोड़ता है और ऐक्टिवेशन फ़ंक्शन के ज़रिए योग को फ़ीड करता है, जैसा कि किसी नियमित सघन परत में मौजूद न्यूरॉन करता है. इसके बाद, एक ही वज़न का इस्तेमाल करके यह कार्रवाई पूरी इमेज में दोहराई जाती है. याद रखें कि घनी लेयर में, हर एक न्यूरॉन का अपना वज़न होता है. यहां, वेट का एक "पैच", इमेज पर दोनों दिशाओं में स्लाइड करता है (एक "कंवोल्यूशन"). आउटपुट में उतनी ही वैल्यू होती हैं जितने पिक्सल इमेज में होते हैं. हालांकि, किनारों पर कुछ पैडिंग ज़रूरी है. यह 4x4x3=48 मोटाई वाले फ़िल्टर का इस्तेमाल करके, फ़िल्टर करने की एक कार्रवाई होती है.
हालांकि, 48 भार काफ़ी नहीं होंगे. ज़्यादा डिग्री ऑफ़ फ़्रीडम जोड़ने के लिए, हम वेट के नए सेट के साथ वही ऑपरेशन दोहराते हैं. इससे फ़िल्टर आउटपुट का एक नया सेट बनता है. इनपुट इमेज में R,G,B चैनलों की तरह ही, इसे आउटपुट का "चैनल" कहें.
नया डाइमेंशन जोड़कर, वेट के दो (या उससे ज़्यादा) सेट को एक टेंसर के तौर पर जोड़ा जा सकता है. इससे हमें कॉन्वोल्यूशनल लेयर के लिए, वेट टेंसर का सामान्य आकार मिलता है. इनपुट और आउटपुट चैनलों की संख्या पैरामीटर होती है. इसलिए, हम कॉन्वोल्यूशनल लेयर को स्टैक और चेन कर सकते हैं.
इलस्ट्रेशन: कॉन्वलूशनल न्यूरल नेटवर्क, डेटा के "क्यूब्स" को डेटा के अन्य "क्यूब्स" में बदलता है.
स्ट्राइड वाले कॉन्वोल्यूशन, मैक्स पूलिंग
दो या तीन की स्ट्राइड के साथ कॉन्वोल्यूशन करने पर, हम नतीजे वाले डेटा क्यूब को उसके हॉरिज़ॉन्टल डाइमेंशन में भी छोटा कर सकते हैं. इसे करने के दो सामान्य तरीके हैं:
- स्ट्राइड वाला कन्वोल्यूशन: ऊपर बताए गए स्लाइडिंग फ़िल्टर की तरह ही, लेकिन स्ट्राइड >1 के साथ
- मैक्स पूलिंग: यह एक स्लाइडिंग विंडो है, जो MAX ऑपरेशन लागू करती है. आम तौर पर, यह 2x2 पैच पर लागू होती है और हर दो पिक्सल के बाद दोहराई जाती है
इलस्ट्रेशन: कंप्यूटिंग विंडो को तीन पिक्सल स्लाइड करने से आउटपुट वैल्यू कम हो जाती है. स्ट्राइड्ड कन्वर्ज़न या मैक्स पूलिंग, हॉरिज़ॉन्टल डाइमेंशन में डेटा क्यूब को छोटा करने का एक तरीका है. मैक्स पूलिंग का मतलब है कि विंडो को 2x2 वाली विंडो पर ले जाना, ज़्यादा से ज़्यादा दो लाइनों के साथ स्लाइड करना है.
Convolutional classifier
आखिर में, हम आखिरी डेटा क्यूब को फ़्लैट करके, उसे सॉफ़्टमैक्स चालू की गई लेयर में फ़ीड करके, क्लासिफ़िकेशन हेड अटैच करते हैं. एक सामान्य कन्वोल्यूशनल क्लासिफ़ायर कुछ ऐसा दिख सकता है:
इलस्ट्रेशन: कॉन्वोल्यूशनल और सॉफ़्टमैक्स लेयर का इस्तेमाल करके इमेज को अलग-अलग कैटगरी में बांटने वाला मॉडल. इसमें 3x3 और 1x1 फ़िल्टर का इस्तेमाल किया जाता है. मैक्सपूल लेयर, 2x2 डेटा पॉइंट के ग्रुप में से सबसे ज़्यादा डेटा पॉइंट लेती हैं. क्लासिफ़िकेशन हेड को सॉफ़्टमैक्स ऐक्टिवेशन के साथ एक सघन लेयर के साथ लागू किया जाता है.
Keras में
ऊपर दिखाए गए कॉन्वोलूशनल स्टैक को Keras में इस तरह लिखा जा सकता है:
model = tf.keras.Sequential([
# input: images of size 192x192x3 pixels (the three stands for RGB channels)
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
tf.keras.layers.Flatten(),
# classifying into 5 categories
tf.keras.layers.Dense(5, activation='softmax')
])
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy'])
6. आपका कस्टम कन्वेंट
हाथों से सीखना
आइए, शुरू से ही एक कॉन्वोल्यूशनल न्यूरल नेटवर्क बनाएं और उसे ट्रेनिंग दें. 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(). है
समाधान
समाधान notebook यहां दी गई है. अगर आपको कोई समस्या आ रही है, तो इसका इस्तेमाल किया जा सकता है.
Keras_Flowers_TPU (solution).ipynb
इसमें हमने इन विषयों के बारे में बताया
- 🤔 कन्वर्ज़न लेयर के साथ चलाया गया
- 🤓 ज़्यादा से ज़्यादा पूल करने की सुविधा, स्ट्राइड, ग्लोबल औसत पूलिंग के प्रयोग किए गए, ...
- 😀 TPU पर, असल दुनिया के मॉडल पर तेज़ी से काम किया
कृपया कुछ समय निकालकर इस चेकलिस्ट को देखें.
7. बधाई हो!
आपने अपना पहला आधुनिक कॉन्वोल्यूशनल न्यूरल नेटवर्क बनाया है और उसे 80% से ज़्यादा सटीक बनाने के लिए ट्रेन किया है. TPU की मदद से, इसके आर्किटेक्चर को सिर्फ़ कुछ मिनट में दोहराया गया है. कॉन्वलूशनल आर्किटेक्चर के बारे में जानने के लिए, कृपया अगले लैब में जाएं:
- TPU-स्पीड डेटा पाइपलाइन: tf.data.Dataset और TFRecords
- ट्रांसफ़र लर्निंग की मदद से, अपना पहला Keras मॉडल बनाना
- [THIS LAB] केराज़ और टीपीयू के साथ कनवलूशनल न्यूरल नेटवर्क
- Keras और TPU के साथ आधुनिक कॉन्वेंट, squeezenet, Xception
TPU का इस्तेमाल
Cloud AI Platform पर, टीपीयू और जीपीयू उपलब्ध हैं:
- डीप लर्निंग वीएम पर
- AI Platform Notebooks में
- AI Platform Training से जुड़ी नौकरियों में
आखिर में, हमें आपके सुझाव, शिकायत या राय पाकर खुशी होगी. अगर आपको इस लैब में कोई गड़बड़ी दिखती है या आपको लगता है कि इसमें सुधार किया जाना चाहिए, तो कृपया हमें बताएं. GitHub की समस्याओं [ सुझाव/राय देने या शिकायत करने के लिए लिंक] के ज़रिए सुझाव, शिकायत या राय दी जा सकती है.
|
