Earth Engine को Google के टूल और सेवाओं के आधार पर बनाया गया है, ताकि बड़े पैमाने पर कंप्यूटेशन किया जा सके. बड़े पैमाने पर जियोस्पेशल विश्लेषण को आसान बनाने के लिए, Earth Engine प्लैटफ़ॉर्म और एपीआई, पैरलल-प्रोसेसिंग इंफ़्रास्ट्रक्चर की ज़्यादातर जटिलताओं को छिपा देते हैं.
ईईसीयू
खास जानकारी
Earth Engine कंप्यूट यूनिट (ईईसीयू), प्रोसेसिंग पावर की मात्रा को दिखाने का एक तरीका है. Earth Engine, टास्क के कुल कंप्यूटेशनल फ़ुटप्रिंट को ट्रैक करता है. इसके लिए, वह समय के साथ ईईसीयू के इस्तेमाल को फ़ंक्शन के तौर पर ट्रैक करता है. जैसे, ईईसीयू-सेकंड, ईईसीयू-घंटे वगैरह. Google के पास कई अलग-अलग तरह के प्रोसेसर कोर, आर्किटेक्चर वगैरह हैं. ईईसीयू, कंप्यूटेशनल पावर के बारे में बात करने के लिए एक उपयोगी ऐब्स्ट्रैक्शन है.
वजह
EE के उपयोगकर्ता अक्सर यह अनुमान लगाना चाहते हैं कि उनके वर्कफ़्लो के लिए कितनी प्रोसेसिंग पावर की ज़रूरत है. EECU, तुलना करने के लिए एक जैसी मेट्रिक उपलब्ध कराता है.
सीपीयू मेट्रिक के साथ तुलना
किसी खास नतीजे पर काम करने वाली मशीनों की संख्या, टाइप, और आर्किटेक्चर समय के साथ बदल सकता है. अलग-अलग फ़िज़िकल कोर की परफ़ॉर्मेंस अलग-अलग हो सकती है. इसलिए, Earth Engine सभी प्रोसेसिंग को ईईसीयू का इस्तेमाल करके ऐब्स्ट्रैक्ट करता है. ईईसीयू-घंटा (या ईईसीयू-समय की कोई अन्य इकाई) दीवार घड़ी के समय से मेल नहीं खाती. इसलिए, 10 ईईसीयू-घंटे खर्च करने वाले किसी काम का रनटाइम सिर्फ़ कुछ मिनट का हो सकता है.
स्थिरता और अनुमान
Earth Engine को एक जैसे अनुरोध भेजने पर, कभी-कभी कंप्यूटेशन की अलग-अलग मात्राएं मिल सकती हैं. अंतर की सामान्य वजहों में ये शामिल हैं:
- कैश मेमोरी में सेव करना, जैसे कि पिछली कंप्यूटेशन के नतीजों का फिर से इस्तेमाल करना. इनमें आंशिक या इंटरमीडिएट नतीजे शामिल हैं
- अलग-अलग बुनियादी डेटा, जैसे कि सैटलाइट से ली गई तस्वीरों की अलग-अलग संख्या, अलग-अलग जटिलता वाली ज्यामिति वगैरह.
- एल्गोरिदम में होने वाले बदलाव. इनमें परफ़ॉर्मेंस को ऑप्टिमाइज़ करना, गड़बड़ियां ठीक करना वगैरह शामिल हैं.
- क्लाइंट लाइब्रेरी में हुए बदलाव, खास तौर पर तब, जब अन्य उपयोगकर्ताओं के EE कोड या पैकेज पर निर्भर रहा जाता है
मानदंड
Earth Engine के कंप्यूटेशन बेंचमार्क के सैंपल देखें.
पूरे न हो पाने वाले अनुरोधों की मेट्रिक
Earth Engine, पूरे न हो पाए अनुरोधों/टास्क के लिए परफ़ॉर्मेंस मेट्रिक उपलब्ध नहीं कराता. ऐसा इसलिए, क्योंकि ये संख्याएं गलत या गुमराह करने वाली हो सकती हैं. उदाहरण के लिए, अगर कोई जॉब इसलिए पूरी नहीं हो पाती है, क्योंकि वर्कर टास्क ने जवाब देना बंद कर दिया है, तो उस वर्कर की प्रोसेसिंग खपत को कुल खपत में शामिल नहीं किया जा सकेगा.
प्रोफ़ाइलर
प्रोफ़ाइलर, ईईसीयू-टाइम और मेमोरी के इस्तेमाल (हर एल्गोरिदम और ऐसेट के हिसाब से) की जानकारी देता है. यह जानकारी, प्रोफ़ाइलर के चालू होने के दौरान की गई कंप्यूटेशन से मिलती है. प्रोफ़ाइलर आउटपुट की हर लाइन, किसी एल्गोरिदम, कंप्यूटेशन, ऐसेट लोड या ओवरहेड ऑपरेशन से जुड़ी होती है. इसके बारे में 'ब्यौरा' कॉलम में बताया गया है. प्रोफ़ाइलर में ये कॉलम होते हैं:
- ब्यौरा
- प्रोफ़ाइल किए जा रहे कंप्यूटेशन, एल्गोरिदम, ऐसेट लोड या ओवरहेड ऑपरेशन का टेक्स्ट के तौर पर ब्यौरा.
- संख्या
- यह इंडिकेटर, 'ब्यौरा' में बताए गए ऑपरेशन को कॉल किए जाने की संख्या के अनुपात में होता है.
- कंप्यूट
- यह इंडिकेटर बताता है कि कार्रवाइयों को पूरा करने में, ईईसीयू के हिसाब से कितना समय लगा.
- मौजूदा सदस्य
यह कॉलम सिर्फ़ तब दिखता है, जब स्क्रिप्ट की वजह से कोई गड़बड़ी हुई हो
बहुत ज़्यादा मेमोरी का इस्तेमाल किया गया. इससे पता चलता है कि गड़बड़ी होने के समय, किसी एक कंप्यूट नोड पर कितनी मेमोरी इस्तेमाल की जा रही थी.
- पीक मेम
कार्रवाई के लिए, किसी एक कंप्यूट नोड पर इस्तेमाल की गई ज़्यादा से ज़्यादा मेमोरी.
प्रोफ़ाइलर चालू करना
कोड एडिटर
"Run with Profiler" बटन का इस्तेमाल करें. इसके बारे में कोड एडिटर की गाइड में बताया गया है.
Python
प्रोफ़ाइलर को चालू करने के लिए, अपनी Python स्क्रिप्ट में यह कोड शामिल करें:
with ee.profilePrinting():
print(ee.Number(3.14).add(0.00159).getInfo())
कॉन्टेक्स्ट खत्म होने पर प्रोफ़ाइल प्रिंट हो जाएगी. भले ही, कॉन्टेक्स्ट में कोई गड़बड़ी हुई हो या नहीं.
प्रोफ़ाइल को स्ट्रिंग के तौर पर कैप्चर करने के लिए, प्रोफ़ाइल को स्ट्रिंग बफ़र में लिखें:
import io
out = io.StringIO()
with ee.profilePrinting(destination=out) as p:
print(ee.Number(3.14).add(0.00159).getInfo())
print('Output:')
print(out.getvalue())
यहां प्रोफ़ाइल स्ट्रिंग को टेबल में बदलने का सुझाव दिया गया है, ताकि Colab और Jupyter Notebooks में आसानी से विश्लेषण किया जा सके. ध्यान दें कि यह सिर्फ़ एक तरीका है और हो सकता है कि यह सभी मामलों के लिए सही न हो:
import re
import pandas as pd
lines = out.getvalue().split('\n')
column_names = re.split(r'\s{1,}', lines[0])
column_names = [name.strip() for name in column_names if name.strip()]
data = [
[element for element in re.split(r'\s{2,}', line) if element.strip()]
for line in lines[1:-1]
]
df = pd.DataFrame(data, columns=column_names)
display(df)