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

खास जानकारी

Earth Engine का कंप्यूटेशनल आर्किटेक्चर, इमेज (पिक्सल पर आधारित) के कंप्यूटेशन को तेज़ और स्केलेबल बनाने के लिए ऑप्टिमाइज़ किया गया है. BigQuery को टेबल वाले डेटा (वेक्टर) को स्केल करने के लिए भी ऑप्टिमाइज़ किया गया है. इसमें कई ऐसी सुविधाएं हैं जिनकी वजह से यह Earth Engine के साथ बेहतर तरीके से काम करती है.

वर्कफ़्लो के उदाहरणों में ये शामिल हैं:

• Earth Engine में जनरेट किए गए डेटा पर, BigQuery के बड़े जॉइन करना
• BigQuery में आगे की प्रोसेसिंग के लिए, इमेज से मिले आंकड़ों के साथ वेक्टर डेटा को एनोटेट करना
• समय-समय पर Earth Engine से डेटा को, ऐसी BigQuery टेबल में एक्सपोर्ट करना जिसमें डेटा जोड़ा जा सकता है

अगर आपके पास इस्तेमाल के दूसरे बेहतर उदाहरण हैं, तो हमें उनके बारे में बताएं!

BigQuery के बारे में बुनियादी जानकारी

Earth Engine, BigQuery टेबल में डेटा डालता है. साथ ही, सभी टेबल, डेटासेट में होती हैं. अगर BigQuery में कोई डेटासेट मौजूद नहीं है, तो एक्सपोर्ट टास्क पूरा नहीं हो पाते. BigQuery डेटासेट के बारे में जानकारी में ज़्यादा जानें.

डेटासेट बनाना

डेटासेट बनाने के समय कई विकल्प होते हैं. इनमें नाम, स्टोरेज क्षेत्र, और खत्म होने का तरीका शामिल है. साथ ही, कई अन्य और बेहतर विकल्प भी होते हैं.

डेटासेट बनाने के कई तरीके हैं. हालांकि, Cloud Console का इस्तेमाल करके, इसे आसानी से बनाया जा सकता है:

1. Cloud Console में BigQuery पेज पर जाएं.
2. अगर कहा जाए, तो एपीआई चालू करने के लिए "चालू करें" पर क्लिक करें.
3. "SQL फ़ाइल फ़ोल्डर" टैब में, प्रोजेक्ट के बगल में मौजूद तीन बिंदु वाले मेन्यू (more_vert) पर क्लिक करें.
4. "डेटासेट बनाएं" विकल्प चुनें.
5. कॉन्फ़िगरेशन गाइड का पालन करें.

डेटासेट बनाने और कॉन्फ़िगर करने के सभी विकल्पों के लिए, BigQuery दस्तावेज़ देखें.

अनुमतियां

Earth Engine का इस्तेमाल करने के लिए, स्टैंडर्ड भूमिकाओं और अनुमतियों के अलावा, कॉल करने वाले के पास Cloud प्रोजेक्ट या डेटासेट के लिए BigQuery की सही अनुमतियां भी होनी चाहिए.

• bigquery.tables.get
• bigquery.tables.create
• bigquery.tables.updateData
• bigquery.tables.delete
• bigquery.jobs.create

पहले से तय पहचान और ऐक्सेस मैनेजमेंट (आईएएम) भूमिकाओं के इनमें से किसी भी कॉम्बिनेशन में ज़रूरी अनुमतियां शामिल होती हैं:

• bigquery.dataEditor के साथ bigquery.jobUser
• bigquery.dataOwner के साथ bigquery.jobUser
• bigquery.user
• bigquery.admin

कीमत

BigQuery, Google Cloud की एक ऐसी सेवा है जिसके लिए पैसे चुकाने होते हैं. इसलिए, BigQuery का इस्तेमाल करने पर आपसे शुल्क लिया जाएगा. इसमें, BigQuery में एक्सपोर्ट किए गए Earth Engine डेटा को स्टोर करने और उसका विश्लेषण करने की सुविधा भी शामिल है.

Earth Engine की BigQuery एक्सपोर्ट सुविधा की कीमत के बारे में जानने के लिए, यहां दिया गया कीमत वाला सेक्शन देखें.

कॉन्फ़िगरेशन एक्सपोर्ट करना

सिंटैक्स

  Export.table.toBigQuery({
    'collection': myFeatureCollection,
    'table': 'myproject.mydataset.mytable',
    'description': 'put_my_data_in_bigquery',
    'append': true,
    'overwrite': false
  });

  task = ee.batch.Export.table.toBigQuery(
      collection=myFeatureCollection,
      table='myproject.mydataset.mytable',
      description='put_my_data_in_bigquery',
      append=True,
      overwrite=False)
  task.start()

स्कीमा की जानकारी अपने-आप जनरेट होना या मैन्युअल तरीके से डालना

अगर BigQuery में कोई टेबल मौजूद नहीं है, तो Earth Engine, कलेक्शन में मौजूद पहले ee.Feature की प्रॉपर्टी का इस्तेमाल करके, स्कीमा तय करने की कोशिश करता है. यह सबसे सही अनुमान है. ऐसा कलेक्शन भी बनाया जा सकता है जिसमें पहली सुविधा का स्कीमा, दूसरी सुविधाओं के स्कीमा से अलग हो.

अगर आपको अपनी BigQuery टेबल पर कोई खास स्कीमा चाहिए, तो टारगेट स्कीमा के साथ खाली टेबल बनाकर उसे कॉन्फ़िगर करें.

प्रॉपर्टी के नाम

Earth Engine की सुविधाओं की प्रॉपर्टी, BigQuery के कॉलम से मेल खाती हैं. Earth Engine, BigQuery में ee.Feature ज्यामिति (".geo" सिलेक्टर) लिखने के लिए, "geo" नाम का इस्तेमाल करता है.

नाम बदलने से बचने के लिए, पक्का करें कि आपके ee.Feature ऑब्जेक्ट में ऐसी प्रॉपर्टी हों जो कॉलम के मान्य नाम हों. साथ ही, किसी भी प्रॉपर्टी का नाम "geo" न हो. ऐसा इसलिए, क्योंकि इस नाम का इस्तेमाल, सुविधा की ज्यामिति के लिए किया जाता है, जिसका Earth Engine में कोई नाम नहीं होता.

प्रॉपर्टी के नामों में अमान्य वर्ण होने पर, डेटा एक्सपोर्ट नहीं हो पाता. ऐसा इसलिए होता है, क्योंकि BigQuery कॉलम के नामों पर पाबंदियां हैं.

टाइप कन्वर्ज़न

जब भी संभव हो, तब Earth Engine (ee.Feature प्रॉपर्टी की वैल्यू) के डेटा को BigQuery टाइप में बदल दिया जाता है. ध्यान दें कि वैल्यू न होने की स्थिति को टेबल स्कीमा कंट्रोल करता है, न कि टाइप.

श्रेणियां

Earth Engine, किसी भी मल्टी-डाइमेंशनल ee.Array को STRUCT<ARRAY<INT64> dimensions, ARRAY<INT64|FLOAT64> values> में एक्सपोर्ट करता है. यह फ़ॉर्मैट, BigQuery के ML.DECODE_IMAGE फ़ंक्शन में इस्तेमाल किए गए फ़ॉर्मैट से मिलता-जुलता है.

स्ट्रक्चर में मौजूद पहले ऐरे, dimensions में Earth Engine ऐरे के डाइमेंशन, $d_1$ से $d_n$ तक होते हैं.

स्ट्रक्चर में मौजूद दूसरे कलेक्शन, values में कई डाइमेंशन वाले कलेक्शन की सभी वैल्यू होती हैं. ये वैल्यू, एक ही BigQuery कलेक्शन में फ़्लैट की जाती हैं. फ़्लैट किए गए ऐरे में वैल्यू की कुल संख्या, $\sum_{i=1}^n d_i$ होती है. साथ ही, ओरिजनल Earth Engine ऐरे में इंडेक्स $(i_i, \ldots, i_n)$ पर मौजूद वैल्यू, फ़्लैट किए गए ऐरे में इस इंडेक्स पर मौजूद वैल्यू से मेल खाती है:

$$\sum_{j=1}^n \left( i_j \cdot \prod_{k=j+1}^n d_k \right)$$

सामान्य मामलों में, values कलेक्शन के लिए इंडेक्स करने वाला एक्सप्रेशन इस तरह का होता है:

उदाहरण के लिए, 2x3x4 Earth Engine कलेक्शन पर विचार करें:

    ee.Array([
      [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12]
      ],
      [
        [13, 14, 15, 16],
        [17, 18, 19, 20],
        [21, 22, 23, 24]
      ]
    ]);

यह ऐरे, BigQuery STRUCT में बदल जाता है, जिसका dimensions एलिमेंट ऐरे [2, 3, 4] है और values एलिमेंट, फ़्लैट किया गया ऐरे [1, 2, 3, 4, 5, 6, 7, 8, ..., 21, 22, 23, 24] है. फ़्लैट किए गए कलेक्शन में इंडेक्स का हिसाब, [(i1 * 12) + (i2 * 4) + i3] के तौर पर लगाया जा सकता है.

JSON वैल्यू

किसी सेल में ज़्यादा बेहतर स्ट्रक्चर्ड डेटा का इस्तेमाल करने के लिए, Earth Engine की वैल्यू को JSON ऑब्जेक्ट के तौर पर कोड में बदला जा सकता है. BigQuery, JSON में कोड में बदले गए डेटा पर SQL ऑपरेशन की सुविधा देता है. इससे, Earth Engine में कोड में बदली गई JSON वैल्यू में "देखने" वाली क्वेरी की सुविधा मिलती है.

var states = ee.FeatureCollection('TIGER/2018/States');
var mod11a1 = ee.ImageCollection('MODIS/061/MOD11A1');

// Find the max day and night temperatures per pixel for a given time.
var maxTemp = mod11a1
    .select(['LST_Day_1km', 'LST_Night_1km'])
    .filterDate('2023-05-15', '2023-05-25')
    .max();

// Annotate each state with its max day/night temperatures.
var annotatedStates = states.map(function (e) {
  var dict = maxTemp.reduceRegion({
    reducer: ee.Reducer.max(),
    geometry: e.geometry(),
    scale: 10 * 1000,  // 10 km
  });
  // Convert the dictionary to JSON and add it as a property.
  return e.set('maxTemp', ee.String.encodeJSON(dict));
});

Export.table.toBigQuery(annotatedStates);

import ee
import geemap.core as geemap

states = ee.FeatureCollection('TIGER/2018/States')
mod11a1 = ee.ImageCollection('MODIS/061/MOD11A1')

# Find the max day and night temperatures per pixel for a given time.
max_temp = (
    mod11a1.select(['LST_Day_1km', 'LST_Night_1km'])
    .filterDate('2023-05-15', '2023-05-25')
    .max()
)


def get_max_temp_for_state(e):
  max_temp_dict = max_temp.reduceRegion(
      reducer=ee.Reducer.max(),
      geometry=e.geometry(),
      scale=10 * 1000,  # 10 km
  )
  # Convert the dictionary to JSON and add it as a property.
  return e.set('maxTemp', ee.String.encodeJSON(max_temp_dict))


# Annotate each state with its max day/night temperatures.
annotated_states = states.map(get_max_temp_for_state)

task = ee.batch.Export.table.toBigQuery(
    collection=annotated_states, table='myproject.mydataset.mytable'
)
task.start()

जियोमेट्री कन्वर्ज़न

BigQuery में अलग-अलग प्रोजेक्शन के लिए सीमित सहायता है. इसलिए, Earth Engine की सभी ज्यामिति को 1 मीटर के गड़बड़ी मार्जिन का इस्तेमाल करके, जियोडेसिक EPSG:4326 में बदल दिया जाता है.

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

var transformedCollection = originalCollection.map(function transformGeo(e) {
  var myErrorMargin = 10 * 1000;  // meters
  return e.setGeometry(e.geometry(myErrorMargin, 'EPSG:4326', true));
});

import ee
import geemap.core as geemap

def transform_geo(e):
  my_error_margin = 10 * 1000  # meters
  return e.setGeometry(e.geometry(my_error_margin, 'EPSG:4326', True))


transformed_collection = original_collection.map(transform_geo)

परफ़ॉर्मेंस

Earth Engine की परफ़ॉर्मेंस

Earth Engine का कैलकुलेशन, अक्सर Export ऑपरेशन के लिए रुकावट बन जाता है. इसके लिए, प्रोसेसिंग को व्यवस्थित करना ज़रूरी है, ताकि एक साथ ज़्यादा से ज़्यादा काम किया जा सके. सीरियल प्रोसेसिंग में होने वाला कोई भी कैलकुलेशन (उदाहरण के लिए, ee.FeatureCollection.iterate()) आपके एक्सपोर्ट को धीरे-धीरे चलने या पूरा न होने की वजह बन सकता है.

BigQuery में परफ़ॉर्मेंस

डेटा को सही तरीके से व्यवस्थित करना और क्लस्टर करना, यह पक्का करने का सबसे अच्छा तरीका है कि BigQuery में क्वेरी को बेहतर बनाया जा सकता है. अगर BigQuery में पहले से कोई टेबल मौजूद नहीं है, तो Earth Engine से एक्सपोर्ट की गई टेबल, सुविधाओं के ज्यामिति (अगर मौजूद है) के आधार पर क्लस्टर की जाती हैं. जियोस्पेशल डेटा के लिए, देश/इलाके के हिसाब से क्लस्टर बनाना बहुत आम है. इससे, स्पेस फ़िल्टर का इस्तेमाल करने वाली क्वेरी की परफ़ॉर्मेंस बेहतर होती है और उनकी लागत कम होती है. आम तौर पर, यह BigQuery के इन ऑपरेशन के लिए होता है:

WHERE ST_DWithin(<table_column>, <constant_geography>, <distance>)

WHERE ST_Intersects(<table_column>, <constant_geography>)

आम तौर पर, क्लस्टर नहीं की गई टेबल में क्लस्टर जोड़ने से भी कोई नुकसान नहीं होता. हालांकि, इससे टेबल में डेटा लोड होने में थोड़ा समय लग सकता है. क्वेरी ऑप्टिमाइज़ेशन के बारे में ज़्यादा जानने के लिए, BigQuery दस्तावेज़ देखें.

ध्यान दें कि क्लस्टर करने की सेटिंग का असर, टेबल में डाले गए नए डेटा पर ही पड़ता है.

डेमो: reduceRegions का इस्तेमाल करना

कुछ मामलों में, Earth Engine के प्रोसेसिंग इन्फ़्रास्ट्रक्चर से ज़्यादा से ज़्यादा पैरलल प्रोसेसिंग पाने के लिए, reduceRegions का इस्तेमाल किया जा सकता है. इस उदाहरण में, reduceRegions कॉल के बजाय कुछ हज़ार reduceRegions कॉल (कलेक्शन पर फ़ंक्शन को मैप करने के लिए आम तौर पर इस्तेमाल किया जाने वाला तरीका) का इस्तेमाल करने का तरीका बताया गया है.reduceRegion

var lucas = ee.FeatureCollection('JRC/LUCAS_HARMO/COPERNICUS_POLYGONS/V1/2018');
var s2 = ee.ImageCollection('COPERNICUS/S2_SR_HARMONIZED');

// Fetch the unique date values from the dataset.
var dates = lucas.aggregate_array('survey_date')
    .distinct()
    .map(function (date) {
      return ee.Date.parse('dd/MM/yy', date);
    });

// For each date, annotate the LUCAS samples with the Sentinel-2 band values for
// a two-week window.
function getLucasSamplesForDate(date) {
  date = ee.Date(date);
  var imageForDate = s2
    .filterDate(
      date.advance(-1, 'week'),
      date.advance(1, 'week'))
    .select('B.*');
  var median = imageForDate.median();
  var lucasForDate = lucas.filter(
    ee.Filter.equals('survey_date', date.format('dd/MM/yy')));
  var sample = median.reduceRegions({
    collection: lucasForDate,
    reducer: ee.Reducer.mean(),
    scale: 10,
    tileScale: 8,
  });
  return sample;
}

// Flatten the collection.
var withSamples =
    ee.FeatureCollection(dates.map(getLucasSamplesForDate))
      .flatten();

Export.table.toBigQuery({
  collection: withSamples,
  description: 'lucas_s2_annotated'
});

import ee
import geemap.core as geemap

lucas = ee.FeatureCollection('JRC/LUCAS_HARMO/COPERNICUS_POLYGONS/V1/2018')
s2 = ee.ImageCollection('COPERNICUS/S2_SR_HARMONIZED')

# Fetch the unique date values from the dataset.
dates = (
    lucas.aggregate_array('survey_date')
    .distinct()
    .map(lambda date: ee.Date.parse('dd/MM/yy', date))
)


# For each date, annotate the LUCAS samples with the Sentinel-2 band values for
# a two-week window.
def get_lucas_samples_for_date(date):
  date = ee.Date(date)
  image_for_date = s2.filterDate(
      date.advance(-1, 'week'), date.advance(1, 'week')
  ).select('B.*')
  median = image_for_date.median()
  lucas_for_date = lucas.filter(
      ee.Filter.equals('survey_date', date.format('dd/MM/yy'))
  )
  sample = median.reduceRegions(
      collection=lucas_for_date,
      reducer=ee.Reducer.mean(),
      scale=10,
      tileScale=8,
  )
  return sample


# Flatten the collection.
with_samples = ee.FeatureCollection(
    dates.map(get_lucas_samples_for_date)
).flatten()

task = ee.batch.Export.table.toBigQuery(
    collection=with_samples,
    table='myproject.mydataset.mytable',
    description='lucas_s2_annotated',
)
task.start()

टास्क को एक साथ चलाना

{append: true} विकल्प की मदद से, एक साथ कई टास्क, BigQuery टेबल में डेटा लिख सकते हैं. यह ज़्यादा थ्रूपुट के साथ डेटा लिखने का एक तरीका है. हालांकि, इसके लिए टास्क की सूची मैनेज करना, फिर से कोशिश करना वगैरह जैसी ज़्यादा जटिल कार्रवाइयां करनी पड़ती हैं.

append और overwrite पैरामीटर के बीच परफ़ॉर्मेंस में अंतर

ध्यान दें कि डेटा को जोड़ने की तुलना में, डेटा को ओवरराइट करने में ज़्यादा समय लगता है. इसकी वजह यह है कि BigQuery को पुराने डेटा को ओवरराइट करने से पहले, नए डेटा को प्रोसेस करना पड़ता है. किसी मौजूदा BigQuery टेबल में डेटा एक्सपोर्ट करते समय, {overwrite: true} पैरामीटर सेट करने पर, डेटा को सुरक्षित तरीके से ओवरराइट करने की प्रोसेस शुरू होती है:

1. अस्थायी टेबल: डेटा को डेस्टिनेशन डेटासेट में मौजूद, नई और अस्थायी टेबल में एक्सपोर्ट किया जाता है.
2. एक बार में पूरा डेटा बदलना: इसमें, अस्थायी टेबल के कॉन्टेंट को आखिरी डेस्टिनेशन टेबल में कॉपी किया जाता है. साथ ही, एक बार में पूरे डेटा को बदल दिया जाता है.
3. क्लीनअप: कुछ समय के लिए सेव की गई टेबल मिट जाती है.

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

बेहतर परफ़ॉर्मेंस वाले विकल्प

जिन वर्कफ़्लो में बहुत ज़्यादा थ्रूपुट की ज़रूरत होती है उनके लिए, Earth Engine से BigQuery में डेटा ट्रांसफ़र करने के लिए GeoBeam का इस्तेमाल करें. इसके लिए, ज़्यादा कॉन्फ़िगरेशन और इन्फ़्रास्ट्रक्चर की ज़रूरत होती है. इसलिए, हमारा सुझाव है कि आप Earth Engine में पहले से मौजूद फ़ंक्शन का इस्तेमाल करें.

कीमत

BigQuery में डेटा एक्सपोर्ट करने की प्रोसेस, एक बैच में होती है. इसमें बैच के ईईसीयू (ईसीयू: एलिमेंट प्रोसेसिंग यूनिट) का समय लगता है. अगर Earth Engine का इस्तेमाल व्यावसायिक या ऑपरेशनल तौर पर किया जाता है, तो BigQuery में डेटा एक्सपोर्ट करने पर, टास्क के लिए इस्तेमाल किए गए ईईसीयू-टाइम के लिए आपसे शुल्क लिया जाता है. Earth Engine के सभी वर्शन के इस्तेमाल को, उन निगरानी टूल की मदद से मॉनिटर किया जा सकता है जो Earth Engine के बाकी वर्शन के लिए काम करते हैं.

Cloud के बिलिंग खाते

BigQuery में डेटा डालने के लिए, उससे जुड़े Cloud प्रोजेक्ट में बिलिंग खाता चालू होना चाहिए. बिलिंग खाते के कॉन्फ़िगरेशन के बारे में ज़्यादा जानने के लिए, Cloud के बिलिंग खाते के दस्तावेज़ देखें.

इग्रेस डेटा ट्रैफ़िक

इनग्रेस और एग्रेस ट्रैफ़िक के लिए, स्टैंडर्ड नेटवर्क ट्रैफ़िक के तौर पर शुल्क लिया जाता है.

Earth Engine सिर्फ़ अमेरिका में होस्ट किया जाता है. हालांकि, BigQuery डेटासेट कई अन्य इलाकों में होस्ट किए जा सकते हैं. शामिल किए गए इलाकों और डेटा के वॉल्यूम के आधार पर, Earth Engine से BigQuery में डेटा लिखने से ज़्यादा नेटवर्क ट्रैफ़िक जनरेट हो सकता है.

ज्ञात समस्याएं

बड़े पॉलीगॉन के लिए ओरिएंटेशन

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

अगर ज़रूरी हो, तो BigQuery एक्सप्रेशन ST_Difference(ST_GeogFromText('fullglobe'), geo) का इस्तेमाल करके, इनवर्ट किए गए पॉलीगॉन को फिर से इनवर्ट करके, BigQuery में ठीक किया जा सकता है.

ज़्यादा जानकारी के लिए, यहां देखें.