इमेज के सुझाव

Earth Engine, Vertex AI पर होस्ट किए गए मॉडल के लिए, ee.Model को कनेक्टर के तौर पर उपलब्ध कराता है. यह कनेक्टर, Vertex AI एंडपॉइंट पर डिप्लॉय किए गए ट्रेन किए गए मॉडल को ऑनलाइन अनुमान के अनुरोधों के तौर पर, इमेज या टेबल का डेटा भेजता है. इसके बाद, मॉडल आउटपुट को Earth Engine इमेज या टेबल के तौर पर दिखाया जाता है.

ee.Model.predictImage

होस्ट किए गए मॉडल का इस्तेमाल करके, ee.Image पर अनुमान लगाने के लिए model.predictImage() का इस्तेमाल करें. ee.Image का इस्तेमाल, बैंड की टाइल (इमेज पैच) बनाने के लिए किया जाता है. इसके बाद, इन्हें होस्ट किए गए मॉडल को भेजा जाता है. predictImage() का रिटर्न टाइप ee.Image है. इसे मैप में जोड़ा जा सकता है, एक्सपोर्ट किया जा सकता है या अन्य कंप्यूटेशन में इस्तेमाल किया जा सकता है.

इनपुट के विकल्प

ee.Image का इस्तेमाल करके अनुमान लगाते समय, ee.Model कनेक्टर में कई पैरामीटर इस्तेमाल किए जाते हैं. ये कंट्रोल, इनपुट बैंड और प्रॉपर्टी, इनपुट इमेज पैच टाइलिंग, आउटपुट इमेज पैच साइज़, और आउटपुट इमेज बैंड के लिए हैं.

बैंड और प्रॉपर्टी

इनपुट बैंड और प्रॉपर्टी की जानकारी देने के लिए, इन पैरामीटर का इस्तेमाल करें:

inputProperties

inputProperties, प्रॉपर्टी के नामों की सूची है. इसे हर अनुमान के इंस्टेंस को भेजा जाता है. न्यूमेरिक, स्ट्रिंग, और बूलियन प्रॉपर्टी का इस्तेमाल किया जा सकता है.

inputTypeOverride

inputTypeOverride, प्रॉपर्टी और/या बैंड के नामों की डिक्शनरी है. इसमें टाइप और डाइमेंशन की खास जानकारी दी गई है. ऐसा करना ज़रूरी हो सकता है, क्योंकि Earth Engine के कई एल्गोरिदम, डाइनैमिक टाइप के आउटपुट बनाते हैं. इनका अनुमान रनटाइम तक नहीं लगाया जा सकता.

उदाहरण के लिए, अगर किसी कलेक्शन पर ee.Terrain.slope फ़ंक्शन को मैप करके "slope" की गणना की जा रही है, तो आपको हमारे अनुमान इनपुट में "slope" के आउटपुट टाइप की जानकारी देनी होगी. जैसे:

inputTypeOverride = {
  "slope": {
    "type": "PixelType",
    "precision": "float",
    "dimensions": 0,
    "min": -100.0,
    "max": 100.0
  }
}

सलाह: अगर आपको गड़बड़ी का यह मैसेज मिलता है कि किसी बैंड या प्रॉपर्टी को "टेंसर में नहीं बदला जा सकता", तो इसका एक संभावित समाधान यह है कि टाइप ओवरराइड का इस्तेमाल करके, इनपुट को किसी दिए गए टाइप में बदला जाए.

inputShapes

inputShapes, बैंड के नामों और ऐरे-पिक्सल के आकार की डिक्शनरी है. अपने मॉडल को एक से ज़्यादा लंबाई वाले अरे-वैल्यू पिक्सल भेजने के लिए, inputShapes आर्ग्युमेंट सेट करें. यह आर्ग्युमेंट inputTypeOverride जैसा ही है. हालांकि, यह इमेज के अनुमान के लिए, इनपुट बैंड के आकार के हिसाब से होता है. उदाहरण के लिए, तीन बैंड को एन्कोड करने के लिए, (1) "ndvi_series" को 12 वैल्यू वाली 1D टाइम सीरीज़ के तौर पर, (2) "temp" को स्केलर के तौर पर, और (3) "patch" को 2D पिक्सल कलेक्शन के तौर पर एन्कोड करने के लिए, यह तरीका अपनाएं:

inputShapes = {
  "ndvi_series": [12],  # 12 ndvi samples
  "temp": [], # scalar
  "patch": [2, 2], # 2px * 2px patch
}

outputBands

outputBands, आउटपुट बैंड के नामों की एक डिक्शनरी है. इसमें बैंड के ee.PixelType और डाइमेंशन शामिल होते हैं. यहां डाइमेंशन, टेंसर शेप अरे की लंबाई के बराबर होने चाहिए. दूसरे शब्दों में, () शेप वाले स्केलर डेटा में डाइमेंशन 0 होना चाहिए. (N) शेप वाले 1D डेटा में डाइमेंशन 1 होना चाहिए. (N, M) शेप वाले 2D डेटा में डाइमेंशन 2 होना चाहिए. उदाहरण के लिए, "B1" नाम के आउटपुट बैंड में, अरे-वैल्यू वाले पिक्सल का आकार इस तरह से तय किया जाता है:

outputBands = {
  'B1': {'type': ee.PixelType.float(), 'dimensions': 1}
}

टाइल के साइज़

इन पैरामीटर का इस्तेमाल करके, यह कंट्रोल किया जा सकता है कि इमेज को टाइल कैसे किया जाए:

  • inputTileSize
  • inputOverlapSize
  • outputTileSize

इनपुट टाइल के साइज़

इनपुट टाइल के साइज़ सेट करने के लिए, inputTileSize और inputOverlapSize का इस्तेमाल करें. इन पैरामीटर को सेट करने के लिए, पिक्सल में टाइल की चौड़ाई और ऊंचाई का एक जोड़ा दें. उदाहरण के लिए, [32, 32]. पैच का कुल साइज़, inputTileSize और outputTileSize की ऊंचाई और चौड़ाई को जोड़कर तय किया जाता है.

उदाहरण के लिए, पूरी तरह से कॉन्वोलूशनल मॉडल को (256 x 256 x चैनल) शेप वाले इनपुट की ज़रूरत हो सकती है. अगर हमें अनुमान के नतीजों के बीच किनारों के असर की चिंता है, तो हम अनुमान के हर नतीजे के बाएं और दाएं हिस्से से inputOverlapSize[0] पिक्सल और ऊपर और नीचे से inputOverlapSize[1] पिक्सल को खारिज कर सकते हैं. इससे, अनुमान वाले इलाके को पूरी तरह से कवर करने के लिए, अनुमान वाले ज़्यादा कॉल किए जाएंगे.

उदाहरण के लिए, अगर हमारे मॉडल को (256 x 256 x 3) की उम्मीद है और हमें 32 बॉर्डर पिक्सल को खारिज करना है, तो हमें यह जानकारी देनी होगी:

ee.Model({
  "endpoint": endpoint,
  "inputTileSize": [192, 192],
  "inputOverlapSize": [64, 64],
  # rest omitted.
}

ध्यान दें: inputOverlapSize, x और y का कुल ओवरलैप है. अगर आपको पूरी इमेज के आस-पास N पिक्सल का बफ़र रखना है, तो ओवरलैप [2N, 2N] होगा

आउटपुट टाइल का साइज़

आउटपुट टाइल का साइज़ सेट करने के लिए, outputTileSize आर्ग्युमेंट सेट करें. अगर outputTileSize सेट नहीं है, तो टाइल का डिफ़ॉल्ट साइज़ inputTileSize के बराबर होता है.

कुछ मॉडल के लिए, आउटपुट का साइज़, इनपुट के साइज़ से अलग हो सकता है. उदाहरण के लिए, क्लासिफ़िकेशन मॉडल (256, 256, चैनल) के आकार वाले इनपुट स्वीकार कर सकता है, लेकिन (1, 1, 1) आकार वाले टेंसर दिखा सकता है. इस मामले में, outputTileSize को [1, 1] पर सेट करना होगा. यह उन मॉडल के साथ काफ़ी आम है जो किसी टाइल की विशेषता की संभावना (कम रिज़ॉल्यूशन पर) का आउटपुट दिखाते हैं.

अनुमान

सभी कॉन्वोलूशनल मॉडल के लिए, इनपुट का प्रोजेक्शन तय होना चाहिए. ऐसा इसलिए होता है, क्योंकि ज़्यादातर कॉन्वोलूशनल मॉडल को एक तय स्केल पर ट्रेनिंग दी जाती है. इस मामले में, ee.Model.fromVertexAi() को कॉल करते समय fixInputProj पैरामीटर को true पर सेट करें. साथ ही, proj पैरामीटर में डेटा का प्रोजेक्शन तय करें.

इनपुट इमेज के प्रोजेक्शन और मॉडल के तय प्रोजेक्शन से, आउटपुट वैल्यू पर असर पड़ेगा. EE रीप्रोजेक्शन गाइड देखें.