TPU पर Keras और मॉडर्न कन्वर्ज़न

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

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

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

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

• Keras और Tensor प्रोसेसिंग यूनिट (टीपीयू) का इस्तेमाल करके, अपने कस्टम मॉडल तेज़ी से बनाए जा सकते हैं.
• ट्रेनिंग डेटा को बेहतर तरीके से लोड करने के लिए, tf.data.Dataset API और TFRecord फ़ॉर्मैट का इस्तेमाल करें.
• दूसरों को धोखा देना 🚫
• Keras के क्रम में चलने वाले और फ़ंक्शनल मॉडल स्टाइल का इस्तेमाल करने के लिए.
• सॉफ़्टमैक्स लेयर और क्रॉस-एंट्रॉपी लॉस के साथ, अपना खुद का Keras क्लासिफ़ायर बनाने के लिए.
• कॉन्वलूशनल लेयर के अच्छे विकल्प के साथ, अपने मॉडल को बेहतर बनाने के लिए.
• यहां आपको मॉड्यूल, ग्लोबल ऐवरेज पूलिंग वगैरह जैसे मॉडर्न कन्वर्ज़न आर्किटेक्चर आइडिया के बारे में जानने का मौका मिलेगा.
• स्क्वीज़नेट आर्किटेक्चर का इस्तेमाल करके, एक सादा और आधुनिक कॉन्नेट बनाने के लिए.

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

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

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

यह लैब, Google Collaboratory का इस्तेमाल करता है और आपको अपनी ओर से किसी सेटअप की ज़रूरत नहीं होती. इसे Chromebook से चलाया जा सकता है. कृपया नीचे दी गई फ़ाइल खोलें और Colab notebook के बारे में जानने के लिए, सेल एक्ज़ीक्यूट करें.

Welcome to Colab.ipynb

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

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

नोटबुक चलाना

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

विषय सूची

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

छिपे हुए सेल

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

पुष्टि करना

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

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

कम शब्दों में

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

Keras में TPU पर मॉडल को ट्रेनिंग देने के लिए कोड (और TPU उपलब्ध न होने पर, जीपीयू या सीपीयू पर वापस जाएं):

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

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

TPU क्यों ?

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

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

हार्डवेयर

MXU और VPU

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

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

MXU, bfloat16 इनपुट और float32 आउटपुट का इस्तेमाल करके, मैट्रिक्स गुणन की गणना करता है. बीच के लेवल पर इकट्ठा किए गए डेटा, float32 सटीक तरीके से चुकाए जाते हैं.

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

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

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

सिस्टोलिक अरे

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

आव्यूह के गुणन का मूल तत्व, एक आव्यूह की रेखा और दूसरे आव्यूह के कॉलम के बीच बिंदु वाला गुणनफल है (इस सेक्शन के सबसे ऊपर दिया गया उदाहरण देखें). किसी मैट्रिक्स गुणा Y=X*W के लिए, नतीजे का एक एलिमेंट यह होगा:

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

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

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

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

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

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

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

TPU पॉड

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

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

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

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

सॉफ़्टवेयर

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

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

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

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

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

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

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

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

Tensorflow 2.1 के बाद से, TPU, Keras API के साथ काम करते हैं. Keras से जुड़ी सहायता, TPU और TPU पॉड पर काम करती है. यहां एक उदाहरण दिया गया है, जो TPU, जीपीयू, और सीपीयू पर काम करता है:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

इस कोड स्निपेट में:

• TPUClusterResolver().connect(), नेटवर्क पर TPU को ढूंढता है. यह Google Cloud के ज़्यादातर सिस्टम (एआई प्लैटफ़ॉर्म की नौकरियां, Colaboratory, Kubeflow, ‘ctpu up' सुविधा से बनाई गई डीप लर्निंग वीएम) पर पैरामीटर के बिना काम करता है. TPU_NAME के एनवायरमेंट वैरिएबल की वजह से, इन सिस्टम को पता चल पाता है कि उनका TPU कहां है. अगर आपने मैन्युअल तरीके से TPU बनाया है, तो TPU_NAME एनवायरमेंट सेट करें. वैरिएबल आप इसका इस्तेमाल कर रहे हैं या TPUClusterResolver को इन खास पैरामीटर के साथ कॉल करें: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy वह हिस्सा है जो डिस्ट्रिब्यूशन और "all-reduce" को लागू करता है ग्रेडिएंट सिंक्रोनाइज़ेशन एल्गोरिदम.
• रणनीति को एक स्कोप की मदद से लागू किया जाता है. मॉडल को रणनीति के दायरे() में ही तय किया जाना चाहिए.
• tpu_model.fit फ़ंक्शन को TPU ट्रेनिंग के लिए, इनपुट के लिए tf.data.Dataset ऑब्जेक्ट की ज़रूरत होती है.

TPU पोर्टिंग से जुड़े सामान्य टास्क

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

4. डेटा लोड हो रहा है

हम फूलों की तस्वीरों के डेटासेट के साथ काम करेंगे. आपका लक्ष्य उन्हें 5 तरह के फूलों की कैटगरी में बांटना सीखना है. डेटा लोड करने के लिए, tf.data.Dataset एपीआई का इस्तेमाल किया जाता है. सबसे पहले, हमें एपीआई के बारे में बताएं.

गतिविधियां खुद करके

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

Fun with tf.data.Dataset (playground).ipynb

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

"फूलों" के बारे में जानकारी डेटासेट

डेटासेट को पांच फ़ोल्डर में व्यवस्थित किया जाता है. हर फ़ोल्डर में एक तरह के फूल हैं. फ़ोल्डर के नाम सनफ़्लावर, डेज़ी, डैंडलायन, ट्यूलिप, और गुलाब हैं. डेटा को Google Cloud Storage पर सार्वजनिक बकेट में होस्ट किया जाता है. उद्धरण:

gs://flowers-public/sunflowers/5139971615_434ff8ed8b_n.jpg
gs://flowers-public/daisy/8094774544_35465c1c64.jpg
gs://flowers-public/sunflowers/9309473873_9d62b9082e.jpg
gs://flowers-public/dandelion/19551343954_83bb52f310_m.jpg
gs://flowers-public/dandelion/14199664556_188b37e51e.jpg
gs://flowers-public/tulips/4290566894_c7f061583d_m.jpg
gs://flowers-public/roses/3065719996_c16ecd5551.jpg
gs://flowers-public/dandelion/8168031302_6e36f39d87.jpg
gs://flowers-public/sunflowers/9564240106_0577e919da_n.jpg
gs://flowers-public/daisy/14167543177_cd36b54ac6_n.jpg

tf.data.Dataset क्यों करना है?

Keras और Tensorflow अपने सभी ट्रेनिंग और आकलन फ़ंक्शन में डेटासेट स्वीकार करते हैं. डेटासेट में डेटा लोड करने के बाद, एपीआई उन सभी सामान्य फ़ंक्शन की सुविधा देता है जो न्यूरल नेटवर्क ट्रेनिंग डेटा के लिए काम की हैं:

dataset = ... # load something (see below)
dataset = dataset.shuffle(1000) # shuffle the dataset with a buffer of 1000
dataset = dataset.cache() # cache the dataset in RAM or on disk
dataset = dataset.repeat() # repeat the dataset indefinitely
dataset = dataset.batch(128) # batch data elements together in batches of 128
AUTOTUNE = tf.data.AUTOTUNE
dataset = dataset.prefetch(AUTOTUNE) # prefetch next batch(es) while training

इस लेख में, परफ़ॉर्मेंस के बारे में सलाह और डेटासेट इस्तेमाल करने के सबसे सही तरीके देखे जा सकते हैं. रेफ़रंस के लिए दस्तावेज़ यहां दिए गए हैं.

tf.data.Dataset की बुनियादी बातें

आम तौर पर, डेटा कई फ़ाइलों में आता है यानी यहां इमेज दी गई हैं. यहां कॉल करके फ़ाइल नामों का डेटासेट बनाया जा सकता है:

filenames_dataset = tf.data.Dataset.list_files('gs://flowers-public/*/*.jpg')
# The parameter is a "glob" pattern that supports the * and ? wildcards.

फिर "मैप" करें एक फ़ंक्शन का इस्तेमाल करें जो आम तौर पर फ़ाइल को मेमोरी में लोड करके असल डेटा में डिकोड कर देगा:

def decode_jpeg(filename):
  bits = tf.io.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  return image

image_dataset = filenames_dataset.map(decode_jpeg)
# this is now a dataset of decoded images (uint8 RGB format)

डेटासेट पर दोहराने के लिए:

for data in my_dataset:
  print(data)

ट्यूपल के डेटासेट

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

def decode_jpeg_and_label(filename):
  bits = tf.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  label = ... # extract flower name from folder name
  return image, label

image_dataset = filenames_dataset.map(decode_jpeg_and_label)
# this is now a dataset of (image, label) pairs 

for image, label in dataset:
  print(image.numpy().shape, label.numpy())

निष्कर्ष:एक-एक करके इमेज लोड होना धीमा है !

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

समाधान

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

Fun with tf.data.Dataset (solution).ipynb

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

• 🤔 tf.data.Dataset.list_files
• 🤔 tf.data.Dataset.map
• 🤔 ट्यूपल के डेटासेट
• डेटासेट के ज़रिए 😀 बार-बार दोहराया जा रहा है

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

5. डेटा तेज़ी से लोड हो रहा है

हम इस लैब में, जो Tensor प्रोसेसिंग यूनिट (TPU) के हार्डवेयर ऐक्सेलरेटर इस्तेमाल करेंगे वे काफ़ी तेज़ी से काम करते हैं. अक्सर चुनौती यह होती है कि उपयोगकर्ताओं को तेज़ी से डेटा फ़ीड किया जाए, ताकि वे व्यस्त रहें. Google Cloud Storage (GCS) की मदद से, डेटा ट्रांसफ़र करने की प्रोसेस बहुत ज़्यादा चलती है. हालांकि, यह सभी क्लाउड स्टोरेज सिस्टम की तरह होता है. इसलिए, एक कनेक्शन बनाने के लिए, कुछ नेटवर्क का इस्तेमाल करना पड़ता है. इसलिए, हमारे डेटा को हज़ारों अलग-अलग फ़ाइलों के तौर पर सेव रखना सही नहीं होता. हम उन्हें कम फ़ाइलों का बैच बनाने जा रहे हैं. साथ ही, कई फ़ाइलों को साथ-साथ पढ़ने के लिए tf.data.Dataset की पावर का इस्तेमाल करेंगे.

रीड-थ्रू

नीचे दी गई नोटबुक में वह कोड मौजूद है जो इमेज फ़ाइलों को लोड करता है, उनका साइज़ बदलकर सामान्य साइज़ में करता है, और फिर उन्हें 16 TFRecord फ़ाइलों में सेव करता है. कृपया इसे तुरंत पढ़ें. इसे एक्ज़ीक्यूट करना ज़रूरी नहीं है, क्योंकि बाकी कोडलैब के लिए, TFRecord के फ़ॉर्मैट वाला डेटा सही तरीके से दिया जाएगा.

Flower pictures to TFRecords.ipynb

जीसीएस के बेहतर थ्रूपुट के लिए सबसे सही डेटा लेआउट

बुनियादी नियम अपने डेटा को कई (10 से 100 सेकंड) की बड़ी फ़ाइलों (10 से 100 एमबी) में बांटना है. उदाहरण के लिए, अगर आपके पास बहुत ज़्यादा फ़ाइलें हैं, तो हज़ारों फ़ाइलों को ऐक्सेस करने का समय आ सकता है. अगर आपके पास एक या दो जैसी बहुत कम फ़ाइलें हैं, तो आपको एक साथ कई फ़ाइलों से स्ट्रीम करने का फ़ायदा नहीं मिल रहा है.

TFRecord फ़ाइल फ़ॉर्मैट

डेटा सेव करने के लिए, Tensorflow का पसंदीदा फ़ाइल फ़ॉर्मैट protobuf पर आधारित TFRecord फ़ॉर्मैट है. क्रम से लगाने के दूसरे फ़ॉर्मैट भी काम करेंगे, लेकिन आप लिखकर डेटासेट को सीधे TFRecord फ़ाइलों से लोड कर सकते हैं:

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

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

AUTOTUNE = tf.data.AUTOTUNE
ignore_order = tf.data.Options()
ignore_order.experimental_deterministic = False

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE)
dataset = dataset.with_options(ignore_order)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

TFRecord की चीट शीट

TFRecords में तीन तरह का डेटा सेव किया जा सकता है: बाइट स्ट्रिंग (बाइट की सूची), 64 बिट इंटीजर और 32 बिट फ़्लोट. इन्हें हमेशा सूचियों के तौर पर सेव किया जाता है. साइज़ 1 की सूची में सिर्फ़ डेटा एलिमेंट शामिल होगा. TFRecords में डेटा सेव करने के लिए, नीचे दिए गए हेल्पर फ़ंक्शन का इस्तेमाल करें.

बाइट स्ट्रिंग लिखना

# warning, the input is a list of byte strings, which are themselves lists of bytes
def _bytestring_feature(list_of_bytestrings):
  return tf.train.Feature(bytes_list=tf.train.BytesList(value=list_of_bytestrings))

इंटीजर लिखना

def _int_feature(list_of_ints): # int64
  return tf.train.Feature(int64_list=tf.train.Int64List(value=list_of_ints))

राइटिंग फ़्लोट

def _float_feature(list_of_floats): # float32
  return tf.train.Feature(float_list=tf.train.FloatList(value=list_of_floats))

ऊपर दिए गए हेल्पर का इस्तेमाल करके TFRecord लिखना

# input data in my_img_bytes, my_class, my_height, my_width, my_floats
with tf.python_io.TFRecordWriter(filename) as out_file:
  feature = {
    "image": _bytestring_feature([my_img_bytes]), # one image in the list
    "class": _int_feature([my_class]),            # one class in the list
    "size": _int_feature([my_height, my_width]),  # fixed length (2) list of ints
    "float_data": _float_feature(my_floats)       # variable length  list of floats
  }
  tf_record = tf.train.Example(features=tf.train.Features(feature=feature))
  out_file.write(tf_record.SerializeToString())

TFRecords का डेटा पढ़ने के लिए, आपको सबसे पहले उन रिकॉर्ड के लेआउट का एलान करना होगा जिन्हें आपने सेव किया है. एलान में, नाम वाले किसी भी फ़ील्ड को तय लंबाई वाली सूची या वैरिएबल की लंबाई वाली सूची के तौर पर ऐक्सेस किया जा सकता है:

TFRecords से पढ़ना

def read_tfrecord(data):
  features = {
    # tf.string = byte string (not text string)
    "image": tf.io.FixedLenFeature([], tf.string), # shape [] means scalar, here, a single byte string
    "class": tf.io.FixedLenFeature([], tf.int64),  # shape [] means scalar, i.e. a single item
    "size": tf.io.FixedLenFeature([2], tf.int64),  # two integers
    "float_data": tf.io.VarLenFeature(tf.float32)  # a variable number of floats
  }

  # decode the TFRecord
  tf_record = tf.io.parse_single_example(data, features)

  # FixedLenFeature fields are now ready to use
  sz = tf_record['size']

  # Typical code for decoding compressed images
  image = tf.io.decode_jpeg(tf_record['image'], channels=3)

  # VarLenFeature fields require additional sparse.to_dense decoding
  float_data = tf.sparse.to_dense(tf_record['float_data'])

  return image, sz, float_data

# decoding a tf.data.TFRecordDataset
dataset = dataset.map(read_tfrecord)
# now a dataset of triplets (image, sz, float_data)

काम के कोड स्निपेट:

सिंगल डेटा एलिमेंट को पढ़ना

tf.io.FixedLenFeature([], tf.string)   # for one byte string
tf.io.FixedLenFeature([], tf.int64)    # for one int
tf.io.FixedLenFeature([], tf.float32)  # for one float

एलिमेंट के तय साइज़ की सूचियों को पढ़ना

tf.io.FixedLenFeature([N], tf.string)   # list of N byte strings
tf.io.FixedLenFeature([N], tf.int64)    # list of N ints
tf.io.FixedLenFeature([N], tf.float32)  # list of N floats

डेटा आइटम की अलग-अलग संख्या को पढ़ना

tf.io.VarLenFeature(tf.string)   # list of byte strings
tf.io.VarLenFeature(tf.int64)    # list of ints
tf.io.VarLenFeature(tf.float32)  # list of floats

varLenFeature एक स्पैर्स वेक्टर दिखाता है और TFRecord को डिकोड करने के बाद एक और चरण पूरा करना पड़ता है:

dense_data = tf.sparse.to_dense(tf_record['my_var_len_feature'])

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

tf.io.FixedLenFeature([], tf.int64, default_value=0) # this field is optional

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

• 🤔 GCS से तेज़ी से ऐक्सेस करने के लिए डेटा फ़ाइलों को शेयर करना
• 👋 TFRecords लिखने का तरीका जानें. (आपको सिंटैक्स याद नहीं है? कोई बात नहीं, इस पेज को चीट शीट के तौर पर बुकमार्क करें)
• 🤔 TFRecordDataset का इस्तेमाल करके TFRecords से डेटासेट लोड करना

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

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

कम शब्दों में

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

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

Keras लेयर के क्रम के तौर पर बनाए गए मॉडल के लिए, सिक्वेंशियल एपीआई उपलब्ध कराया जाता है. उदाहरण के लिए, तीन सघन लेयर वाले इमेज क्लासिफ़ायर को Keras में इस तरह लिखा जा सकता है:

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
    tf.keras.layers.Dense(500, activation="relu"),
    tf.keras.layers.Dense(50, activation="relu"),
    tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

डेंस न्यूरल नेटवर्क

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

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

न्यूरॉन, ऐक्टिवेशन, RELU

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

शब्दावली

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

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

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

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

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

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

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

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

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

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

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

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

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

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

7. ट्रांसफ़र लर्निंग

किसी चित्र वर्गीकरण समस्या के लिए, सघन परतें संभवतः पर्याप्त नहीं होंगी. हमें कॉन्वलूशनल लेयर और उन्हें व्यवस्थित करने के तरीकों के बारे में जानना होगा.

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

हैंड्स-ऑन

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

Keras Flowers transfer learning (playground).ipynb

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

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

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

Keras में ट्रांसफ़र लर्निंग

Keras में, tf.keras.applications.* कलेक्शन से पहले से ट्रेन किए गए मॉडल को इंस्टैंशिएट किया जा सकता है. उदाहरण के लिए MobileNet V2 एक बहुत अच्छा कॉन्वलूशनल आर्किटेक्चर है जो साइज़ को लेकर सही रहता है. include_top=False को चुनने पर, आपको फ़ाइनल सॉफ़्टमैक्स लेयर के बिना पहले से ट्रेन किए गए मॉडल का ऐक्सेस मिलता है, ताकि आप अपना खुद का मॉडल जोड़ सकें:

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

model = tf.keras.Sequential([
    pretrained_model,
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(5, activation='softmax')
])

pretrained_model.trainable = False सेटिंग पर भी ध्यान दें. यह पहले से ट्रेन किए गए मॉडल के वेट और पक्षपात को फ़्रीज़ करता है, ताकि आप सिर्फ़ सॉफ़्टमैक्स लेयर को ट्रेनिंग दे सकें. आम तौर पर, इस प्रक्रिया में काफ़ी कम वेट लागू किए जाते हैं. इसे तेज़ी से पूरा किया जा सकता है. इसके लिए, बहुत बड़े डेटासेट की ज़रूरत नहीं होती. हालांकि, अगर आपके पास ज़्यादा डेटा है, तो pretrained_model.trainable = True के साथ ट्रांसफ़र लर्निंग बेहतर तरीके से काम कर सकती है. इसके बाद, पहले से ट्रेनिंग दिए गए वज़न से शानदार शुरुआती वैल्यू मिलती हैं. ट्रेनिंग की मदद से, इसे अब भी आपकी समस्या के हिसाब से अडजस्ट किया जा सकता है.

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

इस तरीके से आपको 75% सटीक जानकारी मिलती है.

समाधान

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

Keras Flowers transfer learning (solution).ipynb

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

• 🤔 Keras में क्लासिफ़ायर लिखने का तरीका
• 🤓 सॉफ़्टमैक्स आखिरी लेयर के साथ कॉन्फ़िगर किया गया और क्रॉस-एंट्रॉपी लॉस के साथ
• CONTENT ट्रांसफ़र करें
• 🤔 अपने पहले मॉडल को ट्रेनिंग देना
• 🧐 ट्रेनिंग के दौरान खराब होने और सटीक होने के बारे में जानकारी

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

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

कम शब्दों में

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

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

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

Keras में ऐसा सिंपल कॉन्वलूशन न्यूरल नेटवर्क दिखता है:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

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

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

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

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

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

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

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

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

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

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

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

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

इलस्ट्रेशन: इमेज की कैटगरी तय करने वाला एल्गोरिदम, जिसमें कन्वर्ज़न और सॉफ़्टमैक्स लेयर का इस्तेमाल किया गया है. इसमें 3x3 और 1x1 फ़िल्टर का इस्तेमाल किया जाता है. मैक्सपूल लेयर, ज़्यादा से ज़्यादा 2x2 डेटा पॉइंट के ग्रुप के लिए बने होते हैं. क्लासिफ़िकेशन हेड को सॉफ़्टमैक्स ऐक्टिवेशन के साथ एक सघन लेयर के साथ लागू किया जाता है.

Keras में

ऊपर दिखाए गए कॉन्वोलूशनल स्टैक को Keras में इस तरह लिखा जा सकता है:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)    
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

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

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

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

हैंड्स-ऑन

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

Keras_Flowers_TPU (playground).ipynb

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

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

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

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

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

कुछ सलाह:

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

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

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

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

समाधान

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

Keras_Flowers_TPU (solution).ipynb

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

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

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

10. [INFO] आधुनिक कॉन्वोलूशनल आर्किटेक्चर

कम शब्दों में

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

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

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

l = tf.keras.layers # syntax shortcut

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

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

# many more layers ...

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

कम कीमत पर मिलने वाली अन्य तरकीबें

3x3 साइज़ के छोटे फ़िल्टर

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

1x1 कन्वर्ज़न ?

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

11. स्क्वीज़नेट

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

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

हैंड्स-ऑन

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

Keras_Flowers_TPU (playground).ipynb

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

इन ट्रेनिंग के लिए, कृपया ईपीओसीएच की संख्या को 35 तक बढ़ाएं.

इस एक्सरसाइज़ से स्क्विज़नेट मॉड्यूल के लिए हेल्पर फ़ंक्शन तय करने में मदद मिलेगी:

def fire(x, squeeze, expand):
  y = l.Conv2D(filters=squeeze, kernel_size=1, padding='same', activation='relu')(x)
  y1 = l.Conv2D(filters=expand//2, kernel_size=1, padding='same', activation='relu')(y)
  y3 = l.Conv2D(filters=expand//2, kernel_size=3, padding='same', activation='relu')(y)
  return tf.keras.layers.concatenate([y1, y3])

# this is to make it behave similarly to other Keras layers
def fire_module(squeeze, expand):
  return lambda x: fire(x, squeeze, expand)

# usage:
x = l.Input(shape=[192, 192, 3])
y = fire_module(squeeze=24, expand=48)(x) # typically, squeeze is less than expand
y = fire_module(squeeze=32, expand=64)(y)
...
model = tf.keras.Model(x, y)

इस बार का लक्ष्य है 80% सटीक नतीजे पाना.

इन तरीकों को आज़माएं

एक कॉन्वोलूशन लेयर से शुरू करें, फिर MaxPooling2D(pool_size=2) लेयर के साथ बदलते हुए "fire_modules" के साथ फ़ॉलो करें. नेटवर्क में, ज़्यादा से ज़्यादा दो से चार पूलिंग लेयर के साथ एक्सपेरिमेंट किया जा सकता है. साथ ही, मैक्स पूलिंग लेयर के बीच एक, दो या तीन लगातार फ़ायर मॉड्यूल के साथ भी एक्सपेरिमेंट किया जा सकता है.

फ़ायर मॉड्यूल में, "किनारे दबाकर रखें" पैरामीटर आम तौर पर "expand" से छोटा होना चाहिए पैरामीटर. असल में, ये पैरामीटर फ़िल्टर की संख्या होते हैं. आम तौर पर, यह संख्या 8 से 196 तक हो सकती है. ऐसे आर्किटेक्चर के साथ एक्सपेरिमेंट किया जा सकता है जिनमें नेटवर्क के ज़रिए, फ़िल्टर की संख्या धीरे-धीरे बढ़ती है. इसके अलावा, ऐसे सीधे आर्किटेक्चर इस्तेमाल किए जा सकते हैं जिनमें सभी फ़ायर मॉड्यूल में एक जैसे फ़िल्टर हों.

उदाहरण के लिए:

x = tf.keras.layers.Input(shape=[*IMAGE_SIZE, 3]) # input is 192x192 pixels RGB

y = tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu')(x)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.GlobalAveragePooling2D()(y)
y = tf.keras.layers.Dense(5, activation='softmax')(y)

model = tf.keras.Model(x, y)

इस स्थिति में, आपको लग सकता है कि आपके एक्सपेरिमेंट ठीक से काम नहीं कर रहे हैं. साथ ही, 80% सटीक नतीजे पाने का मकसद आपको काफ़ी दूर-दराज़ की लगता है. अब कम कीमत में ढेरों तरकीबों का आनंद लें.

बैच नॉर्मलाइज़ेशन

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

y = tf.keras.layers.BatchNormalization(momentum=0.9)(y)
# please adapt the input and output "y"s to whatever is appropriate in your context

मोमेंटम पैरामीटर को उसकी डिफ़ॉल्ट वैल्यू 0.99 से घटाकर 0.9 करना होगा, क्योंकि हमारा डेटासेट छोटा है. फ़िलहाल, इस जानकारी का ध्यान रखें.

डेटा को बेहतर बनाने की सुविधा

सैचुरेशन बदलावों के बाएं-दाएं फ़्लिप जैसे आसान बदलावों से डेटा को बेहतर बनाने से आपको कुछ और प्रतिशत पॉइंट मिलेंगे:

tf.data.Dataset API की मदद से, Tensorflow में ऐसा करना काफ़ी आसान है. अपने डेटा के लिए, ट्रांसफ़ॉर्मेशन का नया फ़ंक्शन तय करें:

def data_augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_saturation(image, lower=0, upper=2)
    return image, label

इसके बाद, इसे अपने डेटा के फ़ाइनल ट्रांसफ़ॉर्मेशन में इस्तेमाल करें (सेल "ट्रेनिंग और वैलिडेटेशन डेटासेट", फ़ंक्शन "get_batched_dataset"):

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

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

35 युगों में 80% सटीक जानकारी अब पहुंच में होनी चाहिए.

समाधान

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

Keras_Flowers_TPU_squeezenet.ipynb

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

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

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

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

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

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

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

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

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

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

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

अलग करने लायक कॉन्वलूशनल लेयर: 4 x 4 x 3 + 3 x 5 = 48 + 15 = 63

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

हैंड्स-ऑन

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

Keras Flowers transfer learning (playground).ipynb

लक्ष्य: सटीक जानकारी > 95% (नहीं, वाकई में ऐसा किया जा सकता है!)

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

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

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

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

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

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

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

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

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

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

समाधान

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

07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

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

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

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

13. बधाई हो!

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

मौजूदा TPU

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

• डीप लर्निंग वीएम पर
• Vertex AI Notebooks में
• Vertex AI की ट्रेनिंग जॉब की नौकरियों के लिए

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

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