TPU-स्पीड डेटा पाइपलाइन: tf.data.Dataset और TFRecords

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

TPU बहुत तेज़ी से काम करते हैं. ट्रेनिंग डेटा के स्ट्रीम को उनकी ट्रेनिंग की स्पीड के साथ रखा जाना चाहिए. इस लैब में, आपको अपने TPU को फ़ीड करने के लिए, tf.data.Dataset API की मदद से GCS से डेटा लोड करने का तरीका पता चलेगा.

यह लैब "TPU पर केरस" सीरीज़ का पहला पार्ट है. इन चरणों को नीचे दिए गए क्रम में या अलग-अलग क्रम में पूरा किया जा सकता है.

ca8cc21f6838eccc.png

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

  • ट्रेनिंग डेटा लोड करने के लिए, tf.data.Dataset API का इस्तेमाल करने के लिए
  • GCS से ट्रेनिंग डेटा को बेहतर तरीके से लोड करने के लिए, TFRecord फ़ॉर्मैट का इस्तेमाल करना

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

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

2. Google Colaboratory का तुरंत इस्तेमाल शुरू करना

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

688858c21e3beff2.png

Colaboratory के बारे में जानने के लिए, यह सैंपल नोटबुक खोलें और कुछ सेल चलाएं.

c3df49e90e5a654f.png Welcome to Colab.ipynb

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

8832c6208c99687d.png

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

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

76d05caa8b4db6da.png

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

विषय सूची

429f106990037ec4.png

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

छिपे हुए सेल

edc3dba45d26f12a.png

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

पुष्टि करना

cdd4b41413100543.png

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

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

कम शब्दों में

f88cf6facfc70166.png

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 का इस्तेमाल करके, फूलों को अलग-अलग कैटगरी में बांटने वाले मॉडल को इंटरैक्टिव स्पीड (हर ट्रेनिंग रन में कुछ मिनट) पर बनाने और ऑप्टिमाइज़ करने जा रहे हैं.

688858c21e3beff2.png

TPU क्यों ?

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

8eb3e718b8e2ed08.png

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

हार्डवेयर

एमएक्सयू और वीपीयू

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

7d68944718f76b18.png

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

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

19c5fc432840c714.png

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

f1b283fc45966717.gif

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

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

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

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

dfce5522ed644ece.png

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

TPU पॉड

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

2ec1e0d341e7fc34.jpeg

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

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

d97b9cc5d40fdb1d.gif

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

सॉफ़्टवेयर

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

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

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

da534407825f01e3.png

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

अंदरूनी जानकारी: XLA

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

edce61112cd57972.png

उदाहरण: TPU पर चलाने के लिए, आपके Tensorflow प्रोग्राम से तय किए गए कैलकुलेशन ग्राफ़ को पहले XLA (Accelerated Linear Algebra compiler) के तौर पर बदला जाता है. इसके बाद, 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 एनवायरमेंट वैरिएबल सेट करें जिसका इस्तेमाल किया जा रहा है या साफ़ तौर पर पैरामीटर के साथ 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 के तौर पर माना जाता है. टीपीयू में, 32 बिट से कम पर काम करने वाला इंटिजर हार्डवेयर नहीं होता.
  • TensorFlow की कुछ कार्रवाइयां काम नहीं करतीं. सूची यहां दी गई है. अच्छी बात यह है कि यह सीमा सिर्फ़ ट्रेनिंग कोड पर लागू होती है. इसका मतलब है कि आपके मॉडल के फ़ॉरवर्ड और बैकवर्ड पास पर. अब भी अपनी डेटा इनपुट पाइपलाइन में सभी Tensorflow ऑपरेशन का इस्तेमाल किया जा सकता है, क्योंकि यह सीपीयू पर लागू होगा.
  • tf.py_func, TPU पर काम नहीं करता.

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

c0ecb860e4cad0a9.jpeg cc4781a7739c49ae.jpeg 81236b00f8bbf39e.jpeg 961e2228974076bb.jpeg 7517dc163bdffcd5.jpeg 96392df4767f566d.png

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

खुद करके

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

c3df49e90e5a654f.png 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 यहां दी गई है. अगर आपको कोई समस्या आ रही है, तो इसका इस्तेमाल किया जा सकता है.

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

हमने क्या-क्या शामिल किया है

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

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

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

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

रीड-थ्रू

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

c3df49e90e5a654f.png Flower pictures to TFRecords.ipynb

जीसीएस के थ्रूपुट को ऑप्टिमाइज़ करने के लिए, डेटा का सबसे सही लेआउट

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

डेटा सेव करने के लिए, Tensorflow का पसंदीदा फ़ाइल फ़ॉर्मैट प्रोटोबफ़ पर आधारित 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 फ़ाइलों को एक साथ पढ़ सकें. यह कोड, एक साथ कई फ़ाइलों से डेटा पढ़ेगा. साथ ही, डेटा को पढ़ने की रफ़्तार बढ़ाने के लिए, डेटा के क्रम को अनदेखा करेगा.

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 को डेटा डालकर फ़ीड किया जा सकता है. कृपया अगले लैब में जाएं

मौजूदा TPU

Cloud AI Platform पर, टीपीयू और जीपीयू उपलब्ध हैं:

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

HR.png

Martin Görner ID small.jpg
लेखक: मार्टिन गोर्नर
ट्विटर: @martin_gorner