1. खास जानकारी
TPU बहुत तेज़ी से काम करते हैं. ट्रेनिंग डेटा के स्ट्रीम को उनकी ट्रेनिंग की स्पीड के साथ रखा जाना चाहिए. इस लैब में, आपको अपने TPU को फ़ीड करने के लिए, tf.data.Dataset API की मदद से GCS से डेटा लोड करने का तरीका पता चलेगा.
यह लैब, "TPU पर केरस" का पहला पार्ट है सीरीज़ शामिल है. नीचे दिए गए क्रम में या अलग से ऐसा किया जा सकता है.
- [THIS LAB] TPU-स्पीड डेटा पाइपलाइन: tf.data.Dataset और TFRecords
- ट्रांसफ़र लर्निंग के साथ आपका पहला Keras मॉडल
- केरास और टीपीयू के साथ कनवलूशनल न्यूरल नेटवर्क
- Keras और TPU के साथ मॉडर्न कन्वर्ज़न, स्क्वीज़नेट, Xception
आप इन चीज़ों के बारे में जानेंगे
- ट्रेनिंग डेटा लोड करने के लिए, tf.data.Dataset API का इस्तेमाल करने के लिए
- GCS से ट्रेनिंग डेटा को बेहतर तरीके से लोड करने के लिए, TFRecord फ़ॉर्मैट का इस्तेमाल करना
सुझाव, राय या शिकायत
अगर आपको इस कोड लैब में कोई गड़बड़ी दिखती है, तो कृपया हमें बताएं. GitHub की समस्याओं के ज़रिए, सुझाव या राय दी जा सकती है [ feedback link].
2. Google Colaboratory क्विक स्टार्ट
यह लैब, Google Collaboratory का इस्तेमाल करता है और आपको अपनी ओर से किसी सेटअप की ज़रूरत नहीं होती. Colaboratory, शिक्षा के मकसद से बनाया गया एक ऑनलाइन नोटबुक प्लैटफ़ॉर्म है. इसमें सीपीयू, जीपीयू, और TPU की मुफ़्त ट्रेनिंग दी जाती है.
Colaboratory के बारे में जानने के लिए, इस सैंपल नोटबुक को खोला जा सकता है और कुछ सेल को चलाया जा सकता है.
कोई TPU बैकएंड चुनें
Colab मेन्यू में, रनटाइम > रनटाइम टाइप बदलें और फिर TPU चुनें. इस कोड लैब में, हार्डवेयर से तेज़ी से की जाने वाली ट्रेनिंग के लिए इस्तेमाल होने वाला दमदार TPU (Tensor प्रोसेसिंग यूनिट) इस्तेमाल किया जा सकता है. पहली बार एक्ज़ीक्यूशन करने पर, रनटाइम से कनेक्शन अपने-आप हो जाएगा. इसके अलावा, आपके पास "कनेक्ट करें" का इस्तेमाल करने का भी विकल्प है बटन पर क्लिक करें.
नोटबुक चलाना
सेल पर क्लिक करके और Shift-ENTER का इस्तेमाल करके एक-एक करके सेल एक्ज़ीक्यूट करें. रनटाइम > सभी को चलाएं
विषय सूची
सभी नोटबुक में विषय सूची होती है. इसे खोलने के लिए, बाईं ओर मौजूद काले रंग के ऐरो का इस्तेमाल करें.
छिपे हुए सेल
कुछ सेल में सिर्फ़ उनका टाइटल दिखेगा. यह notebook की सुविधा है, जो खास तौर पर 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 कॉलम को गुणा करें और देखें कि यह असल में किसी इमेज की सभी पिक्सल वैल्यू का वेटेड योग कर रहा है या नहीं. कनवॉल्यूशन लेयर को मैट्रिक्स गुणा के तौर पर भी दिखाया जा सकता है. हालांकि, यह थोड़ा जटिल है ( एक्सप्लेनेशन यहां, सेक्शन 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 आउटपुट. इसका मतलब है कि आम तौर पर, कम सटीक परफ़ॉर्मेंस का फ़ायदा पाने के लिए, कोड में किसी तरह के बदलाव की ज़रूरत नहीं होती.
सिस्टोलिक अरे
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.DatasetAPI का इस्तेमाल करना ज़रूरी है. - 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
जीसीएस के बेहतर थ्रूपुट के लिए सबसे सही डेटा लेआउट
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. बधाई हो!
अब TPU को डेटा डालकर फ़ीड किया जा सकता है. कृपया अगले लैब में जाएं
- [THIS LAB] TPU-स्पीड डेटा पाइपलाइन: tf.data.Dataset और TFRecords
- ट्रांसफ़र लर्निंग के साथ आपका पहला Keras मॉडल
- केरास और टीपीयू के साथ कनवलूशनल न्यूरल नेटवर्क
- Keras और TPU के साथ मॉडर्न कन्वर्ज़न, स्क्वीज़नेट, Xception
मौजूदा TPU
TPU और जीपीयू, Cloud AI Platform पर उपलब्ध हैं:
- डीप लर्निंग वीएम पर
- AI Platform Notebooks में
- एआई प्लैटफ़ॉर्म की ट्रेनिंग से जुड़ी नौकरियों के लिए
आखिर में, हमें सुझाव, राय या शिकायत ज़रूर भेजें. अगर आपको इस लैब में कोई गड़बड़ी दिखती है या आपको लगता है कि इसमें सुधार किया जाना चाहिए, तो कृपया हमें बताएं. GitHub की समस्याओं के ज़रिए, सुझाव या राय दी जा सकती है [ feedback link].
|
|
