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

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

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

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

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

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

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

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

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

2. Google Colaboratory को तुरंत शुरू करना

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

इस सैंपल नोटबुक को खोलकर, कुछ सेल चलाएं. इससे आपको Colaboratory के बारे में जानकारी मिलेगी.

Welcome to Colab.ipynb

कोई टीपीयू बैकएंड चुनना

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

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

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

विषय सूची

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

छिपे हुए सेल

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

पुष्टि करना

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

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

कम शब्दों में

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

Keras में TPU पर मॉडल को ट्रेन करने का कोड (अगर TPU उपलब्ध नहीं है, तो GPU या CPU पर वापस आएं):

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

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

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

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

TPU का इस्तेमाल क्यों करें ?

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

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

हार्डवेयर

MXU और VPU

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

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

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

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

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

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

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

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

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

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

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

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

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

Cloud TPU

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

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

TPU पॉड

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

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

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

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

सॉफ़्टवेयर

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

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

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

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

बारीकियों के बारे में जानें: XLA

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

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

Keras में टीपीयू का इस्तेमाल करना

Tensorflow 2.1 से, Keras API के ज़रिए टीपीयू इस्तेमाल किए जा सकते हैं. Keras का इस्तेमाल, टीपीयू और टीपीयू पॉड पर किया जा सकता है. यहां एक ऐसा उदाहरण दिया गया है जो टीपीयू, जीपीयू, और सीपीयू पर काम करता है:

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

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

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

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

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

टीपीयू पर पोर्ट करने से जुड़े सामान्य टास्क

TensorFlow मॉडल में डेटा लोड करने के कई तरीके हैं. हालांकि, टीपीयू के लिए tf.data.Dataset एपीआई का इस्तेमाल करना ज़रूरी है.
टीपीयू बहुत तेज़ होते हैं. इसलिए, टीपीयू पर डेटा प्रोसेस करते समय, डेटा को प्रोसेस करने में लगने वाला समय सबसे ज़्यादा होता है. डेटा बॉटलनेक और परफ़ॉर्मेंस से जुड़ी अन्य सलाह का पता लगाने के लिए, टीपीयू परफ़ॉर्मेंस गाइड में दिए गए टूल का इस्तेमाल किया जा सकता है.
int8 या int16 संख्याओं को int32 के तौर पर माना जाता है. टीपीयू में, 32 बिट से कम पर काम करने वाला पूर्णांक हार्डवेयर नहीं होता.
Tensorflow की कुछ कार्रवाइयां काम नहीं करती हैं. सूची यहां दी गई है. अच्छी बात यह है कि यह सीमा सिर्फ़ ट्रेनिंग कोड पर लागू होती है. इसका मतलब है कि यह सीमा, आपके मॉडल के फ़ॉरवर्ड और बैकवर्ड पास पर लागू होती है. हालांकि, अब भी अपने डेटा इनपुट पाइपलाइन में सभी TensorFlow ऑपरेशनों का इस्तेमाल किया जा सकता है, क्योंकि इन्हें सीपीयू पर एक्ज़ीक्यूट किया जाएगा.
tf.py_func को टीपीयू पर इस्तेमाल नहीं किया जा सकता.

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

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

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

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

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())

नतीजा:एक-एक करके इमेज लोड करने में समय लगता है !

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

समाधान

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

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

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

🤔 tf.data.Dataset.list_files
🤔 tf.data.Dataset.map
🤔 टपल के डेटासेट
😀 डेटासेट के ज़रिए दोहराना

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

5. डेटा को तेज़ी से लोड करना

इस लैब में, हम टेंसर प्रोसेसिंग यूनिट (टीपीयू) हार्डवेयर ऐक्सलरेटर का इस्तेमाल करेंगे. ये बहुत तेज़ होते हैं. इनको व्यस्त रखने के लिए, अक्सर डेटा को तेज़ी से प्रोसेस करना होता है. 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. बधाई हो!

अब टीपीयू को डेटा दिया जा सकता है. कृपया अगले लैब पर जाएं

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

TPU का इस्तेमाल

TPU और GPU, Cloud AI Platform पर उपलब्ध हैं:

डीप लर्निंग वीएम पर
AI Platform Notebooks में
AI Platform Training की नौकरियों में

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

Martin Görner ID small.jpg
लेखक: मार्टिन गर्नर
Twitter: @martin_gorner