TFRecord और Earth Engine

TFRecord एक बाइनरी फ़ॉर्मैट है, जिसका इस्तेमाल tf.Example प्रोटोस के लंबे क्रम को बेहतर तरीके से एन्कोड करने के लिए किया जाता है. TensorFlow, tf.data पैकेज की मदद से TFRecord फ़ाइलों को आसानी से लोड करता है. इस बारे में ज़्यादा जानने के लिए, यहां और यहां जाएं. इस पेज पर बताया गया है कि Earth Engine, ee.FeatureCollection या ee.Image और TFRecord फ़ॉर्मैट के बीच कैसे बदलाव करता है.

डेटा को TFRecord में एक्सपोर्ट करना

टेबल (ee.FeatureCollection) या इमेज (ee.Image) को Google Drive या Cloud Storage में मौजूद TFRecord फ़ाइलों में एक्सपोर्ट किया जा सकता है. एक्सपोर्ट का कॉन्फ़िगरेशन इस बात पर निर्भर करता है कि आपको क्या एक्सपोर्ट करना है. इस बारे में यहां बताया गया है. Earth Engine से TFRecord में एक्सपोर्ट की गई सभी संख्याओं को फ़्लोट टाइप में बदल दिया जाता है.

टेबल एक्सपोर्ट करना

किसी ee.FeatureCollection को TFRecord फ़ाइल में एक्सपोर्ट करते समय, टेबल में मौजूद हर ee.Feature और TFRecord फ़ाइल में मौजूद हर tf.train.Example (यानी हर रिकॉर्ड) के बीच 1:1 संबंध होता है. ee.Feature की हर प्रॉपर्टी को tf.train.Feature के तौर पर कोड में बदला जाता है. इसमें, प्रॉपर्टी में सेव की गई संख्या या ee.Array से जुड़ी फ़्लोट की सूची होती है. अगर प्रॉपर्टी में ऐरे वाली टेबल एक्सपोर्ट की जाती है, तो आपको TensorFlow को ऐरे के रीड होने के समय, उसके आकार के बारे में बताना होगा. TFRecord फ़ाइल में एक्सपोर्ट की गई टेबल को हमेशा GZIP कंप्रेसन टाइप के साथ कंप्रेस किया जाएगा. हर एक्सपोर्ट के लिए, आपको हमेशा एक ही TFRecord फ़ाइल मिलती है.

इस उदाहरण में, स्केलर प्रॉपर्टी ('B2',...,'B7', 'landcover') की एक्सपोर्ट की गई टेबल से डेटा पार्स करने का तरीका बताया गया है. ध्यान दें कि फ़्लोट सूचियों का डाइमेंशन [1] है और टाइप tf.float32 है:

Python

dataset = tf.data.TFRecordDataset(exportedFilePath)

featuresDict = {
  'B2': tf.io.FixedLenFeature(shape=[1], dtype=tf.float32),
  'B3': tf.io.FixedLenFeature(shape=[1], dtype=tf.float32),
  'B4': tf.io.FixedLenFeature(shape=[1], dtype=tf.float32),
  'B5': tf.io.FixedLenFeature(shape=[1], dtype=tf.float32),
  'B6': tf.io.FixedLenFeature(shape=[1], dtype=tf.float32),
  'B7': tf.io.FixedLenFeature(shape=[1], dtype=tf.float32),
  'landcover': tf.io.FixedLenFeature(shape=[1], dtype=tf.float32)
}

parsedDataset = dataset.map(lambda example: tf.io.parse_single_example(example, featuresDict))
        

ध्यान दें कि इस उदाहरण में स्केलर फ़ीचर (यानी shape=[1]) को पढ़ने के बारे में बताया गया है. अगर 2D या 3D ऐरे (जैसे, इमेज पैच) एक्सपोर्ट किए जा रहे हैं, तो आपको पार्स करने के समय अपने पैच का आकार बताना होगा. उदाहरण के लिए, 16x16 पिक्सल पैच के लिए shape=[16, 16].

इमेज एक्सपोर्ट करना

किसी इमेज को एक्सपोर्ट करने पर, डेटा को चैनल, ऊंचाई, चौड़ाई (सीएचडब्ल्यू) के क्रम में लगाया जाता है. एक्सपोर्ट को कई TFRecord फ़ाइलों में बांटा जा सकता है. हर फ़ाइल में patchSize साइज़ के एक या एक से ज़्यादा पैच होते हैं. पैच का साइज़, उपयोगकर्ता एक्सपोर्ट में तय करता है. maxFileSize पैरामीटर में उपयोगकर्ता ने फ़ाइलों का साइज़ बाइट में तय किया है. इस प्रोसेस के बाद बनी TFRecord फ़ाइल में, हर पैच और हर tf.train.Example के बीच 1:1 का संबंध होता है. इमेज के हर बैंड को हर tf.train.Example में अलग-अलग tf.train.Feature के तौर पर सेव किया जाता है. यहां हर फ़ीचर में सेव की गई फ़्लोट सूची की लंबाई, पैच की चौड़ाई * ऊंचाई होती है. फ़्लैट की गई सूचियों को कई अलग-अलग पिक्सल में बांटा जा सकता है, जैसा कि इस उदाहरण में दिखाया गया है. इसके अलावा, एक्सपोर्ट किए गए पैच का आकार, इस उदाहरण में बताए गए तरीके से भी वापस पाया जा सकता है.

किनारों पर होने वाले असर को कम करने के लिए, एक्सपोर्ट किए गए पैच ओवरलैप किए जा सकते हैं. खास तौर पर, आपके पास ऐसा kernelSize तय करने का विकल्प है जिससे टाइल का साइज़ इनमें से कोई एक होगा:

[patchSize[0] + kernelSize[0], patchSize[1] + kernelSize[1]]
    

हर टाइल, आस-पास की टाइल से [kernelSize[0]/2, kernelSize[1]/2] ओवरलैप होती है. इस वजह से, साइज़ patchSize के पैच के किनारे के पिक्सल पर केंद्रित, साइज़ kernelSize के कर्नेल में पूरी तरह से मान्य डेटा होता है. स्पेस में पैच के व्यवस्थित होने का तरीका, पहले चित्र में दिखाया गया है. इसमें पैडिंग डाइमेंशन, उस हिस्से से जुड़ा है जो अगली इमेज पर ओवरलैप होता है:

पहली इमेज. इमेज पैच को एक्सपोर्ट करने का तरीका. पैडिंग डाइमेंशन kernelSize/2 है.

formatOptions

patchSize, maxFileSize, और kernelSize पैरामीटर को formatOptions डिक्शनरी के ज़रिए ee.Export (JavaScript) या ee.batch.Export (Python) कॉल में पास किया जाता है. यहां कुंजियां, Export में पास किए गए अतिरिक्त पैरामीटर के नाम होती हैं. TFRecord फ़ॉर्मैट में एक्सपोर्ट की गई इमेज के लिए, ये formatOptions हो सकते हैं:

प्रॉपर्टी	ब्यौरा	टाइप
patchDimensions	एक्सपोर्ट किए जाने वाले एरिया पर टाइल किए गए डाइमेंशन, जो बॉउंडिंग बॉक्स के हर पिक्सल को ठीक एक बार कवर करते हैं. हालांकि, ऐसा तब नहीं होता, जब पैच डाइमेंशन, बॉउंडिंग बॉक्स को बराबर हिस्सों में न बांटते हों. ऐसे में, सबसे बड़े x/y किनारों के साथ बॉर्डर टाइल हटा दी जाएंगी. डाइमेंशन की वैल्यू 0 से ज़्यादा होनी चाहिए.	Array<int>[2].
kernelSize	अगर मार्जिन डाइमेंशन तय किए जाते हैं, तो टाइल को मार्जिन डाइमेंशन के हिसाब से, ऊपर और नीचे, दोनों तरफ़ बफ़र किया जाएगा. इस वजह से, आस-पास के पैच ओवरलैप हो जाएंगे. अगर यह पैरामीटर दिया गया है, तो दो डाइमेंशन (क्रमशः X और Y) देने होंगे.	Array<int>[2]. डिफ़ॉल्ट: [1, 1]
compressed	अगर यह सही है, तो .tfrecord फ़ाइलों को gzip की मदद से कंप्रेस करता है और ".gz" सफ़िक्स जोड़ता है	बूलियन. डिफ़ॉल्ट: true
maxFileSize	एक्सपोर्ट किए गए .tfrecord का ज़्यादा से ज़्यादा साइज़ (कंप्रेस करने से पहले), बाइट में. फ़ाइल का साइज़ छोटा होने पर, ज़्यादा शर्डिंग होगी. इससे, ज़्यादा आउटपुट फ़ाइलें भी बनेंगी.	इंट. डिफ़ॉल्ट: 1 जीबी
defaultValue	आंशिक या पूरी तरह से मास्क किए गए पिक्सल के हर बैंड में सेट की गई वैल्यू और ऐरे बैंड से बनाई गई आउटपुट 3D सुविधा में हर वैल्यू पर सेट की गई वैल्यू, जहां सोर्स पिक्सल में ऐरे की लंबाई, सुविधा की वैल्यू की गहराई से कम थी (यानी कि ऐरे बैंड में लंबाई 2 के ऐरे पिक्सल के इंडेक्स 3 पर वैल्यू, जिसमें सुविधा की गहराई 3 है). इंटीजर टाइप के बैंड के लिए, आंशिक हिस्से को हटा दिया जाता है और बैंड टाइप की रेंज में क्लैंप कर दिया जाता है. डिफ़ॉल्ट रूप से, यह वैल्यू 0 पर सेट होती है.	Int. डिफ़ॉल्ट: 0
tensorDepths	इनपुट ऐरे बैंड के नामों से, उन 3D टेंसर की डेप्थ पर मैपिंग करना जो वे बनाते हैं. तय किए गए शेप में फ़िट करने के लिए, ऐरे को छोटा किया जाएगा या डिफ़ॉल्ट वैल्यू के साथ पैड किया जाएगा. हर ऐरे बैंड के लिए, इस फ़ील्ड में उससे जुड़ी एंट्री होनी चाहिए.	Array<int>[]. डिफ़ॉल्ट: []
sequenceData	अगर यह सही है, तो हर पिक्सल को स्केलर बैंड को कॉन्टेक्स्ट और अरे बैंड को उदाहरण के क्रम पर मैप करने वाले SequenceExample के तौर पर आउटपुट किया जाता है. SequenceExamples, हर पैच में पिक्सल के पंक्ति-मुख्य क्रम में और फिर फ़ाइल क्रम में, क्षेत्र के पैच के पंक्ति-मुख्य क्रम में आउटपुट होते हैं.	बूलियन. डिफ़ॉल्ट: गलत
collapseBands	अगर यह सही है, तो सभी बैंड को एक ही 3D टेंसर में जोड़ दिया जाएगा. साथ ही, इमेज में पहले बैंड का नाम भी इस्तेमाल किया जाएगा. सभी बैंड को बाइट, int64, और फिर फ़्लोट में प्रमोट किया जाता है. ऐसा, सभी बैंड में सबसे आखिर में मौजूद टाइप के आधार पर किया जाता है. जब तक tensor_depths की वैल्यू दी जाती है, तब तक ऐरे के लिए बैंड की अनुमति होती है.	बूलियन. डिफ़ॉल्ट: गलत
maskedThreshold	पैच में मास्क किए गए पिक्सल का ज़्यादा से ज़्यादा अनुपात. इस सीमा से ज़्यादा के पैच, फ़ाइलों में लिखे जाने के बजाय हटा दिए जाएंगे. अगर इस फ़ील्ड को 1 के अलावा किसी और वैल्यू पर सेट किया जाता है, तो JSON साइडकार जनरेट नहीं होगा. डिफ़ॉल्ट रूप से 1 पर सेट होती है.	फ़्लोट. डिफ़ॉल्ट: 1

TFRecord “mixer” फ़ाइल

TFRecord में एक्सपोर्ट करने पर, Earth Engine आपकी TFRecord फ़ाइलों के साथ एक साइडकार जनरेट करेगा, जिसे “मिक्सर” कहा जाता है. यह एक सामान्य JSON फ़ाइल है, जिसका इस्तेमाल पैच के स्पेस में होने वाले बदलावों (जैसे, जियोरेफ़रंसिंग) को तय करने के लिए किया जाता है. इस फ़ाइल की ज़रूरत, इमेजरी के आधार पर किए गए अनुमान अपलोड करने के लिए होती है. इस बारे में अगले सेक्शन में बताया गया है.

टाइम सीरीज़ एक्सपोर्ट करना

इमेज को Examples और SequenceExamples, दोनों में एक्सपोर्ट किया जा सकता है. Examples में एक्सपोर्ट करने पर, एक्सपोर्ट किए जाने वाले क्षेत्र को पैच में काट दिया जाता है. इसके बाद, उन पैच को पंक्ति के हिसाब से क्रम में, कुछ .tfrecord फ़ाइलों में एक्सपोर्ट कर दिया जाता है. साथ ही, हर बैंड में अपनी सुविधा होती है (जब तक कि आपने collapseBands नहीं बताया है). SequenceExamples में एक्सपोर्ट करने पर, हर पिक्सल के लिए एक SequenceExample एक्सपोर्ट किया जाएगा. साथ ही, उन SequenceExamples को पैच में पंक्ति के हिसाब से क्रम में और फिर ओरिजनल एक्सपोर्ट क्षेत्र में पैच के पंक्ति के हिसाब से क्रम में एक्सपोर्ट किया जाएगा. अगर आपको कभी भी पक्के तौर पर नहीं पता है, तो हमेशा यह मान लें कि चीज़ें किसी न किसी तरह से पंक्ति के हिसाब से क्रम में होंगी. ध्यान दें: किसी इमेज के स्केलर बैंड, SequenceExample के संदर्भ में पैक किए जाएंगे, जबकि ऐरे बैंड, असल सीक्वेंस डेटा बन जाएंगे.

ऐरे बैंड

जब किसी इमेज को TFRecord फ़ॉर्मैट में एक्सपोर्ट किया जाता है, तब ऐरे बैंड एक्सपोर्ट किए जा सकते हैं. ऐरे बैंड को एक्सपोर्ट करने से, SequenceExamples की “FeatureLists” को पॉप्युलेट करने का एक तरीका मिलता है. साथ ही, सामान्य उदाहरणों में एक्सपोर्ट करते समय 3D टेंसर बनाने का एक तरीका भी मिलता है. ऐरे बैंड की लंबाई/गहराई को मैनेज करने के तरीके के बारे में जानने के लिए, ऊपर दी गई टेबल में collapseBands और/या tensorDepths देखें. ध्यान दें: collapseBands का इस्तेमाल करने और SequenceExamples में एक्सपोर्ट करने पर (इसलिए, पैरामीटर sequenceData सेट करना), सभी बैंड को हर पिक्सल के लिए एक टाइम सीरीज़ में छोटा कर दिया जाएगा.

Earth Engine में TFRecords अपलोड करना

टेबल (सिर्फ़ कमांड-लाइन) और इमेज को Earth Engine में, TFRecord फ़ाइलों के तौर पर अपलोड किया जा सकता है. टेबल के लिए, 1:1 का संबंध पहले बताया गया है, जो उलटी दिशा में लागू होता है (यानी tf.train.Example -> ee.Feature).

इमेज अपलोड करना

अगर एक्सपोर्ट की गई इमेज पर अनुमान जनरेट किए जाते हैं, तो भौगोलिक संदर्भ वाली इमेज पाने के लिए, अनुमान (TFRecord फ़ाइलों के तौर पर) अपलोड करते समय मिक्सर को दें. ध्यान दें कि पैच के ओवरलैप होने वाले हिस्से (पहले इमेज में पैडिंग डाइमेंशन) को हटा दिया जाएगा, ताकि एक्सपोर्ट किए गए इलाके की सीमा एक जैसी हो. अनुमानों को tf.train.Example क्रम में व्यवस्थित किया जाना चाहिए. यह क्रम, उतना ही होना चाहिए जितना आपने मूल रूप से एक्सपोर्ट की गई इमेज के उदाहरणों के लिए तय किया था. भले ही, फ़ाइलों की संख्या कितनी भी हो.