במסמך הזה מתוארות שיטות תכנות שנועדו למקסם את הסיכוי להצלחה של חישובים מורכבים או יקרים ב-Earth Engine. השיטות שמתוארות כאן רלוונטיות גם לחישובים אינטראקטיביים (למשל, עורך הקוד) וגם לחישובים באצווה (Export), אבל בדרך כלל צריך להריץ חישובים ארוכים במערכת האצווה.
אל תערבבו פונקציות ואובייקטים של הלקוח עם פונקציות ואובייקטים של השרת
אובייקטים של שרת Earth Engine הם אובייקטים עם פונקציות בנאי שמתחילות ב-ee (למשל ee.Image, ee.Reducer), וכל השיטות באובייקטים כאלה הן פונקציות שרת. כל אובייקט שלא נוצר באופן הזה הוא אובייקט לקוח. אובייקטים של לקוח יכולים להגיע מעורך הקוד (למשל Map, Chart) או משפת JavaScript (למשל Date, Math, [], {}).
כדי למנוע התנהגות לא מכוונת, אל תערבבו פונקציות של לקוח ושל שרת בסקריפט, כפי שמוסבר כאן, כאן וכאן. בדף הזה ו/או במדריך הזה מוסבר לעומק ההבדל בין לקוח לשרת ב-Earth Engine. הדוגמה הבאה ממחישה את הסכנות בשילוב של פונקציונליות בצד הלקוח ובצד השרת:
שגיאה — הקוד הזה לא עובד.
var table = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017');
// Won't work.
for(var i=0; i<table.size(); i++) {
print('No!');
}
אתם יכולים לזהות את השגיאה? חשוב לזכור ש-table.size() היא שיטת שרת באובייקט שרת, ואי אפשר להשתמש בה עם פונקציונליות בצד הלקוח, כמו התנאי <.
מצב שבו כדאי להשתמש בלולאות for הוא בהגדרת ממשק המשתמש, כי האובייקטים והשיטות של ui בעורך הקוד נמצאים בצד הלקוח. מידע נוסף על יצירת ממשקי משתמש ב-Earth Engine לדוגמה:
שימוש בפונקציות של הלקוח להגדרת ממשק המשתמש.
var panel = ui.Panel();
for(var i=1; i<8; i++) {
panel.widgets().set(i, ui.Button('button ' + i))
}
print(panel);
לעומת זאת, map() היא פונקציה בצד השרת, והפונקציונליות בצד הלקוח לא תפעל בתוך הפונקציה שמועברת אל map(). לדוגמה:
שגיאה — הקוד הזה לא עובד.
var table = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017');
// Error:
var foobar = table.map(function(f) {
print(f); // Can't use a client function here.
// Can't Export, either.
});
כדי לבצע פעולה בכל רכיב באוסף, map() פונקציה על האוסף וset() מאפיין:
משתמשים ב-map() וב-set()!
var table = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017');
print(table.first());
// Do something to every element of a collection.
var withMoreProperties = table.map(function(f) {
// Set a property.
return f.set('area_sq_meters', f.area())
});
print(withMoreProperties.first());
אפשר גם filter() את האוסף על סמך מאפיינים מחושבים או קיימים, וprint() את התוצאה. שימו לב: אי אפשר להדפיס אוסף עם יותר מ-5,000 פריטים. אם מופיעה השגיאה "Collection query aborted after accumulating over 5000 elements", צריך filter() או limit() את האוסף לפני ההדפסה.
אל תמירו לרשימה שלא לצורך
האוספים ב-Earth Engine מעובדים באמצעות אופטימיזציות שמופרעות על ידי המרת האוסף לסוג List או Array. אם אתם לא צריכים גישה אקראית לרכיבי אוסף (כלומר, אתם צריכים לקבל את הרכיב ה-i של אוסף), השתמשו במסננים באוסף כדי לגשת לרכיבי אוסף ספציפיים. הדוגמה הבאה ממחישה את ההבדל בין המרת סוג (לא מומלץ) לבין סינון (מומלץ) כדי לגשת לאלמנט באוסף:
אל תמירו לרשימה שלא לצורך!
var table = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017');
// Do NOT do this!!
var list = table.toList(table.size());
print(list.get(13)); // User memory limit exceeded.
חשוב לזכור שאם ממירים אוסף לרשימה שלא לצורך, זה יכול לגרום לשגיאות בקלות. הדרך הבטוחה יותר היא להשתמש ב-filter():
שימוש ב-filter()!
print(table.filter(ee.Filter.eq('country_na', 'Niger')).first());
חשוב להשתמש במסננים בשלב מוקדם ככל האפשר בניתוח.
הימנעות מee.Algorithms.If()
אל תשתמשו ב-ee.Algorithms.If() כדי להטמיע לוגיקה של הסתעפות, במיוחד בפונקציה ממופה. כמו שאפשר לראות בדוגמה הבאה, ee.Algorithms.If() יכול לצרוך הרבה זיכרון, ולכן לא מומלץ להשתמש בו:
אל תשתמשו ב-If()!
var table = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017');
// Do NOT do this!
var veryBad = table.map(function(f) {
return ee.Algorithms.If({
condition: ee.String(f.get('country_na')).compareTo('Chad').gt(0),
trueCase: f, // Do something.
falseCase: null // Do something else.
});
}, true);
print(veryBad); // User memory limit exceeded.
// If() may evaluate both the true and false cases.
שימו לב שהארגומנט השני של map() הוא true. זה אומר שהפונקציה הממופה יכולה להחזיר ערכי null, והם יוסרו מהאוסף שיתקבל.
זה יכול להיות שימושי (בלי If()), אבל כאן הפתרון הכי קל הוא להשתמש במסנן:
שימוש ב-filter()!
print(table.filter(ee.Filter.eq('country_na', 'Chad')));
כפי שמוצג במדריך הזה, גישת תכנות פונקציונלית באמצעות מסננים היא הדרך הנכונה להחיל לוגיקה אחת על חלק מהרכיבים של אוסף, ולוגיקה אחרת על הרכיבים האחרים של האוסף.
הימנעות מreproject()
אל תשתמשו ב-reproject אלא אם זה הכרחי. אחת הסיבות לשימוש ב-reproject() היא לאלץ את החישובים של Code Editor להתבצע בקנה מידה ספציפי, כדי שתוכלו לבחון את התוצאות בקנה המידה הרצוי לניתוח. בדוגמה הבאה, מחושבים אזורים של פיקסלים חמים ומספר הפיקסלים בכל אזור. מריצים את הדוגמה ולוחצים על אחד מהטלאים. שימו לב שמספר הפיקסלים שונה בין הנתונים שהוטלו מחדש לבין הנתונים שלא הוטלו מחדש.
var l8sr = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2');
var sf = ee.Geometry.Point([-122.405, 37.786]);
Map.centerObject(sf, 13);
// A reason to reproject - counting pixels and exploring interactively.
var image = l8sr.filterBounds(sf)
.filterDate('2019-06-01', '2019-12-31')
.first();
image = image.multiply(0.00341802).add(149); // Apply scale factors.
Map.addLayer(image, {bands: ['ST_B10'], min: 280, max: 317}, 'image');
var hotspots = image.select('ST_B10').gt(317)
.selfMask()
.rename('hotspots');
var objectSize = hotspots.connectedPixelCount(256);
Map.addLayer(objectSize, {min: 1, max: 256}, 'Size No Reproject', false);
// Beware of reproject! Don't zoom out on reprojected data.
var reprojected = objectSize.reproject(hotspots.projection());
Map.addLayer(reprojected, {min: 1, max: 256}, 'Size Reproject', false);
הסיבה לפער היא שקנה המידה של הניתוח מוגדר לפי רמת הזום של עורך הקוד. כשקוראים ל-reproject(), אתם מגדירים את קנה המידה של החישוב במקום עורך הקוד. השתמשו ב-reproject() בזהירות רבה מהסיבות שמתוארות במסמך הזה.
קודם מסננים וselect()
באופן כללי, כדאי לסנן אוספי קלט לפי זמן, מיקום ו/או מטא-נתונים לפני שעושים משהו אחר עם האוסף. הפעילו מסננים סלקטיביים יותר לפני מסננים פחות סלקטיביים. מסננים מרחביים ו/או זמניים הם בדרך כלל סלקטיביים יותר. לדוגמה, שימו לב שהכללים select() ו-filter() חלים לפני הכלל map():
var images = ee.ImageCollection('COPERNICUS/S2_SR_HARMONIZED');
var sf = ee.Geometry.Point([-122.463, 37.768]);
// Expensive function to reduce the neighborhood of an image.
var reduceFunction = function(image) {
return image.reduceNeighborhood({
reducer: ee.Reducer.mean(),
kernel: ee.Kernel.square(4)
});
};
var bands = ['B4', 'B3', 'B2'];
// Select and filter first!
var reasonableComputation = images
.select(bands)
.filterBounds(sf)
.filterDate('2018-01-01', '2019-02-01')
.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 1))
.aside(print) // Useful for debugging.
.map(reduceFunction)
.reduce('mean')
.rename(bands);
var viz = {bands: bands, min: 0, max: 10000};
Map.addLayer(reasonableComputation, viz, 'reasonableComputation');
שימוש ב-updateMask() במקום ב-mask()
ההבדל בין updateMask() לבין mask() הוא שהראשון מבצע and() לוגי של הארגומנט (המסכה החדשה) ומסכת התמונה הקיימת, ואילו mask() פשוט מחליף את מסכת התמונה בארגומנט. הסכנה בשיטה השנייה היא שאתם עלולים לחשוף פיקסלים בטעות. בדוגמה הזו, המטרה היא להסתיר פיקסלים בגובה של 300 מטרים או פחות. כמו שאפשר לראות (אם מקטינים את התצוגה), השימוש ב-mask() גורם להרבה פיקסלים להפוך ללא מוסתרים, פיקסלים שלא שייכים לתמונה הרלוונטית:
var l8sr = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2');
var sf = ee.Geometry.Point([-122.40554461769182, 37.786807309873716]);
var aw3d30 = ee.Image('JAXA/ALOS/AW3D30_V1_1');
Map.centerObject(sf, 7);
var image = l8sr.filterBounds(sf)
.filterDate('2019-06-01', '2019-12-31')
.first();
image = image.multiply(0.0000275).subtract(0.2); // Apply scale factors.
var vis = {bands: ['SR_B4', 'SR_B3', 'SR_B2'], min: 0, max: 0.3};
Map.addLayer(image, vis, 'image', false);
var mask = aw3d30.select('AVE').gt(300);
Map.addLayer(mask, {}, 'mask', false);
// NO! Don't do this!
var badMask = image.mask(mask);
Map.addLayer(badMask, vis, 'badMask');
var goodMask = image.updateMask(mask);
Map.addLayer(goodMask, vis, 'goodMask', false);
שילוב של פונקציות reducer
אם אתם צריכים כמה נתונים סטטיסטיים (למשל, ממוצע וסטיית תקן) מקלט אחד (למשל, אזור בתמונה), יעיל יותר לשלב בין מפחיתים. לדוגמה, כדי לקבל נתונים סטטיסטיים של תמונות, משלבים את המפחיתים באופן הבא:
var image = ee.Image(
'COPERNICUS/S2_HARMONIZED/20150821T111616_20160314T094808_T30UWU');
// Get mean and SD in every band by combining reducers.
var stats = image.reduceRegion({
reducer: ee.Reducer.mean().combine({
reducer2: ee.Reducer.stdDev(),
sharedInputs: true
}),
geometry: ee.Geometry.Rectangle([-2.15, 48.55, -1.83, 48.72]),
scale: 10,
bestEffort: true // Use maxPixels if you care about scale.
});
print(stats);
// Extract means and SDs to images.
var meansImage = stats.toImage().select('.*_mean');
var sdsImage = stats.toImage().select('.*_stdDev');
בדוגמה הזו, שימו לב שהמפחית הממוצע משולב עם המפחית של סטיית התקן, ו-sharedInputs הוא True כדי לאפשר מעבר יחיד דרך פיקסלי הקלט. במילון הפלט, שם המפחית מצורף לשם הרצועה. כדי לקבל תמונות של ממוצע וסטיית תקן (לדוגמה, כדי לנרמל את תמונת הקלט), אפשר להפוך את הערכים לתמונה ולהשתמש בביטויים רגולריים כדי לחלץ ממוצעים וסטיות תקן בנפרד, כמו שמוצג בדוגמה.
שימוש ב-Export
אם חישובים מסוימים גורמים לשגיאות "User memory limit exceeded" או "Computation timed out" ב-Code Editor, יכול להיות שאפשר יהיה להשלים את אותם חישובים באמצעות Export. הסיבה לכך היא שזמני הקצובות לתפוגה ארוכים יותר והזיכרון שבשימוש גדול יותר כשמריצים במערכת האצווה (שבה הייצוא פועל). (יש גישות אחרות שאפשר לנסות קודם, כפי שמפורט במסמך ניפוי הבאגים). בהמשך לדוגמה הקודמת, נניח שהמילון החזיר שגיאה. כדי לקבל את התוצאות, אפשר לעשות משהו כזה:
var link = '86836482971a35a5e735a17e93c23272';
Export.table.toDrive({
collection: ee.FeatureCollection([ee.Feature(null, stats)]),
description: 'exported_stats_demo_' + link,
fileFormat: 'CSV'
});
שימו לב שהקישור מוטמע בשם הנכס, כדי שיהיה אפשר לשחזר אותו. שימו לב שאם אתם רוצים לייצא את toAsset, תצטרכו לספק גיאומטריה, שיכולה להיות כל דבר, למשל מרכז הכובד של התמונה, שהוא קטן וזול לחישוב. (כלומר, אל תשתמשו בגיאומטריה מורכבת אם אין צורך בכך).
בדף ניפוי הבאגים יש דוגמאות לשימוש ב-Export כדי לפתור את השגיאות Computation timed out ו-Too many concurrent aggregations. במסמך הזה מוסבר איך לייצא באופן כללי.
אם אין צורך לחתוך, אל תשתמשו ב-clip()
שימוש מיותר ב-clip() יגדיל את זמן החישוב. הימנעו משימוש ב-clip(), אלא אם זה הכרחי לניתוח שלכם. אם אתם לא בטוחים, אל תיצרו קליפ. דוגמה לשימוש לא נכון בקליפ:
אל תחתכו קטעים מהקלט שלא לצורך
var table = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017');
var l8sr = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2');
var belgium = table.filter(ee.Filter.eq('country_na', 'Belgium')).first();
// Do NOT clip unless you need to.
var unnecessaryClip = l8sr
.select('SR_B4') // Good.
.filterBounds(belgium.geometry()) // Good.
.filterDate('2019-01-01', '2019-04-01') // Good.
.map(function(image) {
return image.clip(belgium.geometry()); // NO! Bad! Not necessary.
})
.median()
.reduceRegion({
reducer: ee.Reducer.mean(),
geometry: belgium.geometry(),
scale: 30,
maxPixels: 1e10,
});
print(unnecessaryClip);
אפשר לדלג לגמרי על חיתוך תמונות הקלט, כי האזור מצוין בקריאה ל-reduceRegion():
ציינו את האזור של הפלט
var noClipNeeded = l8sr
.select('SR_B4') // Good.
.filterBounds(belgium.geometry()) // Good.
.filterDate('2019-01-01', '2019-12-31') // Good.
.median()
.reduceRegion({
reducer: ee.Reducer.mean(),
geometry: belgium.geometry(), // Geometry is specified here.
scale: 30,
maxPixels: 1e10,
});
print(noClipNeeded);
אם החישוב הזה נכשל בגלל זמן קצוב לתפוגה, צריך Export אותו כמו בדוגמה הזו.
אם צריך לחתוך עם אוסף מורכב, משתמשים ב-clipToCollection()
אם אתם ממש צריכים לחתוך משהו, והצורות שבהן אתם רוצים להשתמש לחיתוך נמצאות באוסף, השתמשו ב-clipToCollection():
var ecoregions = ee.FeatureCollection('RESOLVE/ECOREGIONS/2017');
var image = ee.Image('JAXA/ALOS/AW3D30_V1_1');
var complexCollection = ecoregions
.filter(ee.Filter.eq('BIOME_NAME',
'Tropical & Subtropical Moist Broadleaf Forests'));
Map.addLayer(complexCollection, {}, 'complexCollection');
var clippedTheRightWay = image.select('AVE')
.clipToCollection(complexCollection);
Map.addLayer(clippedTheRightWay, {}, 'clippedTheRightWay', false);
אל תשתמשו ב-featureCollection.geometry() או ב-featureCollection.union() באוספים גדולים או מורכבים, כי הם עלולים לצרוך יותר זיכרון.
אל תשתמשו באוסף מורכב כאזור של פונקציית צמצום
אם אתם צריכים לבצע צמצום מרחבי כך שהמצמצם יאחד קלטים מכמה אזורים ב-FeatureCollection, אל תספקו את featureCollection.geometry() כקלט geometry למצמצם. במקום זאת, צריך להשתמש ב-clipToCollection() ובאזור שגדול מספיק כדי להכיל את גבולות האוסף. לדוגמה:
var ecoregions = ee.FeatureCollection('RESOLVE/ECOREGIONS/2017');
var image = ee.Image('JAXA/ALOS/AW3D30_V1_1');
var complexCollection = ecoregions
.filter(ee.Filter.eq('BIOME_NAME', 'Tropical & Subtropical Moist Broadleaf Forests'));
var clippedTheRightWay = image.select('AVE')
.clipToCollection(complexCollection);
Map.addLayer(clippedTheRightWay, {}, 'clippedTheRightWay');
var reduction = clippedTheRightWay.reduceRegion({
reducer: ee.Reducer.mean(),
geometry: ee.Geometry.Rectangle({
coords: [-179.9, -50, 179.9, 50], // Almost global.
geodesic: false
}),
scale: 30,
maxPixels: 1e12
});
print(reduction); // If this times out, export it.
צריך להשתמש בערך errorMargin שאינו אפס
בפעולות גיאומטריות שעלולות להיות יקרות, השתמשו בטווח השגיאה הגדול ביותר האפשרי בהתאם לדיוק הנדרש של החישוב. מרווח השגיאה מציין את השגיאה המקסימלית המותרת (במטרים) במהלך פעולות על גיאומטריות (למשל, במהלך הטלה מחדש). אם מציינים מרווח טעות קטן, יכול להיות שיהיה צורך להגדיל את צפיפות הגיאומטריות (באמצעות קואורדינטות), וזה עלול לצרוך הרבה זיכרון. מומלץ לציין מרווח טעות גדול ככל האפשר לחישוב:
var ecoregions = ee.FeatureCollection('RESOLVE/ECOREGIONS/2017');
var complexCollection = ecoregions.limit(10);
Map.centerObject(complexCollection);
Map.addLayer(complexCollection);
var expensiveOps = complexCollection.map(function(f) {
return f.buffer(10000, 200).bounds(200);
});
Map.addLayer(expensiveOps, {}, 'expensiveOps');
אל תשתמשו בקנה מידה קטן באופן מגוחך עם reduceToVectors()
אם אתם רוצים להמיר תמונת רסטר לווקטור, השתמשו בקנה מידה מתאים. אם מציינים קנה מידה קטן מאוד, עלות החישוב יכולה לעלות באופן משמעותי. הגדירו את קנה המידה לערך הגבוה ביותר האפשרי בהתאם לרמת הדיוק הנדרשת. לדוגמה, כדי לקבל פוליגונים שמייצגים את שטחי היבשה בעולם:
var etopo = ee.Image('NOAA/NGDC/ETOPO1');
// Approximate land boundary.
var bounds = etopo.select(0).gt(-100);
// Non-geodesic polygon.
var almostGlobal = ee.Geometry.Polygon({
coords: [[-180, -80], [180, -80], [180, 80], [-180, 80], [-180, -80]],
geodesic: false
});
Map.addLayer(almostGlobal, {}, 'almostGlobal');
var vectors = bounds.selfMask().reduceToVectors({
reducer: ee.Reducer.countEvery(),
geometry: almostGlobal,
// Set the scale to the maximum possible given
// the required precision of the computation.
scale: 50000,
});
Map.addLayer(vectors, {}, 'vectors');
בדוגמה הקודמת, שימו לב לשימוש במצולע לא גיאודזי לשימוש בהפחתות גלובליות.
לא להשתמש ב-reduceToVectors() עם reduceRegions()
אל תשתמשו ב-FeatureCollection שמוחזר על ידי reduceToVectors() כקלט ל-reduceRegions(). במקום זאת, הוסיפו את התדרים שאתם רוצים להפחית לפני הקריאה לפונקציה reduceToVectors():
var etopo = ee.Image('NOAA/NGDC/ETOPO1');
var mod11a1 = ee.ImageCollection('MODIS/061/MOD11A1');
// Approximate land boundary.
var bounds = etopo.select(0).gt(-100);
// Non-geodesic polygon.
var almostGlobal = ee.Geometry.Polygon({
coords: [[-180, -80], [180, -80], [180, 80], [-180, 80], [-180, -80]],
geodesic: false
});
var lst = mod11a1.first().select(0);
var means = bounds.selfMask().addBands(lst).reduceToVectors({
reducer: ee.Reducer.mean(),
geometry: almostGlobal,
scale: 1000,
maxPixels: 1e10
});
print(means.limit(10));
שימו לב שיש דרכים אחרות לצמצם פיקסלים של תמונה אחת בתוך אזורים של תמונה אחרת, כולל reduceConnectedCommponents() ו/או grouping reducers.
שימוש במשתנה fastDistanceTransform() לפעולות שכונה
בפעולות קונבולוציה מסוימות, יכול להיות ש-fastDistanceTransform() יהיה יעיל יותר מ-reduceNeighborhood() או מ-convolve(). לדוגמה, כדי לבצע שחיקה או התרחבות של קלט בינארי:
var aw3d30 = ee.Image('JAXA/ALOS/AW3D30_V1_1');
// Make a simple binary layer from a threshold on elevation.
var mask = aw3d30.select('AVE').gt(300);
Map.setCenter(-122.0703, 37.3872, 11);
Map.addLayer(mask, {}, 'mask');
// Distance in pixel units.
var distance = mask.fastDistanceTransform().sqrt();
// Threshold on distance (three pixels) for a dilation.
var dilation = distance.lt(3);
Map.addLayer(dilation, {}, 'dilation');
// Do the reverse for an erosion.
var notDistance = mask.not().fastDistanceTransform().sqrt();
var erosion = notDistance.gt(3);
Map.addLayer(erosion, {}, 'erosion');
שימוש באופטימיזציות ב-reduceNeighborhood()
אם אתם צריכים לבצע קונבולוציה ואי אפשר להשתמש ב-fastDistanceTransform(), השתמשו באופטימיזציות ב-reduceNeighborhood().
var l8raw = ee.ImageCollection('LANDSAT/LC08/C02/T1_RT');
var composite = ee.Algorithms.Landsat.simpleComposite(l8raw);
var bands = ['B4', 'B3', 'B2'];
var optimizedConvolution = composite.select(bands).reduceNeighborhood({
reducer: ee.Reducer.mean(),
kernel: ee.Kernel.square(3),
optimization: 'boxcar' // Suitable optimization for mean.
}).rename(bands);
var viz = {bands: bands, min: 0, max: 72};
Map.setCenter(-122.0703, 37.3872, 11);
Map.addLayer(composite, viz, 'composite');
Map.addLayer(optimizedConvolution, viz, 'optimizedConvolution');
אל תדגמו יותר נתונים ממה שאתם צריכים
אל תתפתו להגדיל את מערך הנתונים לאימון שלא לצורך. למרות שהגדלת כמות נתוני האימון היא אסטרטגיה יעילה של למידת מכונה בנסיבות מסוימות, היא גם יכולה להגדיל את עלות החישוב בלי עלייה תואמת ברמת הדיוק. (כדי להבין מתי להגדיל את קבוצת הנתונים לאימון, עיינו במאמר הזה). בדוגמה הבאה אפשר לראות איך בקשה של יותר מדי נתוני אימון יכולה לגרום לשגיאה המפחידה "הערך המחושב גדול מדי":
אל תדגמו יותר מדי נתונים
var l8raw = ee.ImageCollection('LANDSAT/LC08/C02/T1_RT');
var composite = ee.Algorithms.Landsat.simpleComposite(l8raw);
var labels = ee.FeatureCollection('projects/google/demo_landcover_labels');
// No! Not necessary. Don't do this:
labels = labels.map(function(f) { return f.buffer(100000, 1000); });
var bands = ['B2', 'B3', 'B4', 'B5', 'B6', 'B7'];
var training = composite.select(bands).sampleRegions({
collection: labels,
properties: ['landcover'],
scale: 30
});
var classifier = ee.Classifier.smileCart().train({
features: training,
classProperty: 'landcover',
inputProperties: bands
});
print(classifier.explain()); // Computed value is too large
הגישה הטובה יותר היא להתחיל עם כמות מתונה של נתונים ולכוונן את הפרמטרים של המסווג כדי לקבוע אם אפשר להשיג את הדיוק הרצוי:
כוונון היפר-פרמטרים
var l8raw = ee.ImageCollection('LANDSAT/LC08/C02/T1_RT');
var composite = ee.Algorithms.Landsat.simpleComposite(l8raw);
var labels = ee.FeatureCollection('projects/google/demo_landcover_labels');
// Increase the data a little bit, possibly introducing noise.
labels = labels.map(function(f) { return f.buffer(100, 10); });
var bands = ['B2', 'B3', 'B4', 'B5', 'B6', 'B7'];
var data = composite.select(bands).sampleRegions({
collection: labels,
properties: ['landcover'],
scale: 30
});
// Add a column of uniform random numbers called 'random'.
data = data.randomColumn();
// Partition into training and testing.
var training = data.filter(ee.Filter.lt('random', 0.5));
var testing = data.filter(ee.Filter.gte('random', 0.5));
// Tune the minLeafPopulation parameter.
var minLeafPops = ee.List.sequence(1, 10);
var accuracies = minLeafPops.map(function(p) {
var classifier = ee.Classifier.smileCart({minLeafPopulation: p})
.train({
features: training,
classProperty: 'landcover',
inputProperties: bands
});
return testing
.classify(classifier)
.errorMatrix('landcover', 'classification')
.accuracy();
});
print(ui.Chart.array.values({
array: ee.Array(accuracies),
axis: 0,
xLabels: minLeafPops
}));
בדוגמה הזו, הסיווג כבר מדויק מאוד, כך שאין הרבה מה לכוונן. יכול להיות שתרצו לבחור את העץ הקטן ביותר האפשרי (כלומר, הערך הגדול ביותר של minLeafPopulation) שעדיין יש לו את הדיוק הנדרש.
Export תוצאות ביניים
נניח שהמטרה שלכם היא לקחת דגימות מתמונה מחושבת מורכבת יחסית. בדרך כלל יעיל יותר Export את התמונה toAsset(), לטעון את התמונה שיוצאה ואז לדגום. לדוגמה:
var image = ee.Image('UMD/hansen/global_forest_change_2025_v1_13');
var geometry = ee.Geometry.Polygon(
[[[-76.64069800085349, 5.511777325802095],
[-76.64069800085349, -20.483938229362376],
[-35.15632300085349, -20.483938229362376],
[-35.15632300085349, 5.511777325802095]]], null, false);
var testRegion = ee.Geometry.Polygon(
[[[-48.86726050085349, -3.0475996402515717],
[-48.86726050085349, -3.9248707849303295],
[-47.46101050085349, -3.9248707849303295],
[-47.46101050085349, -3.0475996402515717]]], null, false);
// Forest loss in 2016, to stratify a sample.
var loss = image.select('lossyear');
var loss16 = loss.eq(16).rename('loss16');
// Scales and masks Landsat 8 surface reflectance images.
function prepSrL8(image) {
var qaMask = image.select('QA_PIXEL').bitwiseAnd(parseInt('11111', 2)).eq(0);
var opticalBands = image.select('SR_B.').multiply(0.0000275).add(-0.2);
var thermalBands = image.select('ST_B.*').multiply(0.00341802).add(149.0);
return image.addBands(opticalBands, null, true)
.addBands(thermalBands, null, true)
.updateMask(qaMask);
}
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2')
.map(prepSrL8);
// Create two annual cloud-free composites.
var composite1 = collection.filterDate('2015-01-01', '2015-12-31').median();
var composite2 = collection.filterDate('2017-01-01', '2017-12-31').median();
// We want a strtatified sample of this stack.
var stack = composite1.addBands(composite2)
.float(); // Export the smallest size possible.
// Export the image. This block is commented because the export is complete.
/*
var link = '0b8023b0af6c1b0ac7b5be649b54db06'
var desc = 'Logistic_regression_stack_' + link;
Export.image.toAsset({
image: stack,
description: desc,
assetId: desc,
region: geometry,
scale: 30,
maxPixels: 1e10
})
*/
// Load the exported image.
var exportedStack = ee.Image(
'projects/google/Logistic_regression_stack_0b8023b0af6c1b0ac7b5be649b54db06');
// Take a very small sample first, to debug.
var testSample = exportedStack.addBands(loss16).stratifiedSample({
numPoints: 1,
classBand: 'loss16',
region: testRegion,
scale: 30,
geometries: true
});
print(testSample); // Check this in the console.
// Take a large sample.
var sample = exportedStack.addBands(loss16).stratifiedSample({
numPoints: 10000,
classBand: 'loss16',
region: geometry,
scale: 30,
});
// Export the large sample...
בדוגמה הזו, שימו לב שהתמונות מיוצאות כ-float. אל תייצאו בדיוק כפול אלא אם זה הכרחי. כשמבצעים את הייצוא הזה, חשוב לשים לב שקישור לעורך הקוד (שמתקבל מיד לפני הייצוא) מוטמע בשם הקובץ כדי לאפשר שחזור.
אחרי שהייצוא מסתיים, טוענים מחדש את הנכס וממשיכים לדגום ממנו. שימו לב: קודם כל מריצים דגימה קטנה מאוד על אזור בדיקה קטן מאוד, כדי לנפות באגים. אם זה מצליח, אפשר לקחת דגימה גדולה יותר ולייצא אותה.
בדרך כלל צריך לייצא דגימות גדולות כאלה. אל תצפו שהדגימות האלה יהיו זמינות באופן אינטראקטיבי (לדוגמה, דרך print()) או שיהיה אפשר להשתמש בהן (לדוגמה, כקלט למסווג) בלי לייצא אותן קודם.
הצטרפות לעומת סינון מפה
נניח שאתם רוצים לאחד אוספים על סמך זמן, מיקום או מאפיין מטא-נתונים כלשהו. בדרך כלל, הדרך היעילה ביותר לעשות זאת היא באמצעות צירוף. בדוגמה הבאה מתבצע איחוד מרחבי-זמני בין האוספים של Landsat 8 ו-Sentinel-2:
var s2 = ee.ImageCollection('COPERNICUS/S2_HARMONIZED')
.filterBounds(ee.Geometry.Point([-2.0205, 48.647]));
var l8 = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2');
var joined = ee.Join.saveAll('landsat').apply({
primary: s2,
secondary: l8,
condition: ee.Filter.and(
ee.Filter.maxDifference({
difference: 1000 * 60 * 60 * 24, // One day in milliseconds
leftField: 'system:time_start',
rightField: 'system:time_start',
}),
ee.Filter.intersects({
leftField: '.geo',
rightField: '.geo',
})
)
});
print(joined);
למרות שכדאי לנסות קודם את הפעולה join (Export אם צריך), לפעמים גם filter() בתוך map() יכול להיות יעיל, במיוחד באוספים גדולים מאוד.
var s2 = ee.ImageCollection('COPERNICUS/S2_HARMONIZED')
.filterBounds(ee.Geometry.Point([-2.0205, 48.647]));
var l8 = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2');
var mappedFilter = s2.map(function(image) {
var date = image.date();
var landsat = l8
.filterBounds(image.geometry())
.filterDate(date.advance(-1, 'day'), date.advance(1, 'day'));
// Return the input image with matching scenes in a property.
return image.set({
landsat: landsat,
size: landsat.size()
});
}).filter(ee.Filter.gt('size', 0));
print(mappedFilter);
reduceRegion() לעומת reduceRegions() לעומת לולאת for
קריאה ל-reduceRegions() עם FeatureCollection גדול או מורכב מאוד כקלט עלולה לגרום לשגיאה המפחידה "הערך המחושב גדול מדי". פתרון אפשרי אחד הוא למפות את reduceRegion() על פני FeatureCollection במקום זאת. פתרון אפשרי נוסף הוא להשתמש בלולאת for. למרות שמומלץ מאוד להימנע מכך ב-Earth Engine, כפי שמתואר במאמרים Map (what to do instead of a for-loop), Functional programming concepts ו-Loop, אפשר להטמיע את reduceRegion() בלולאת for כדי לבצע צמצומים גדולים.
נניח שהמטרה שלכם היא לקבל את ממוצע הפיקסלים (או כל נתון סטטיסטי אחר) בכל ישות ב-FeatureCollection לכל תמונה ב-ImageCollection.
בדוגמה הבאה מוצגת השוואה בין שלוש הגישות שתוארו קודם:
// Table of countries.
var countriesTable = ee.FeatureCollection("USDOS/LSIB_SIMPLE/2017");
// Time series of images.
var mod13a1 = ee.ImageCollection("MODIS/061/MOD13A1");
// MODIS vegetation indices (always use the most recent version).
var band = 'NDVI';
var imagery = mod13a1.select(band);
// Option 1: reduceRegions()
var testTable = countriesTable.limit(1); // Do this outside map()s and loops.
var data = imagery.map(function(image) {
return image.reduceRegions({
collection: testTable,
reducer: ee.Reducer.mean(),
scale: 500
}).map(function(f) {
return f.set({
time: image.date().millis(),
date: image.date().format()
});
});
}).flatten();
print(data.first());
// Option 2: mapped reduceRegion()
var data = countriesTable.map(function(feature) {
return imagery.map(function(image) {
return ee.Feature(feature.geometry().centroid(100),
image.reduceRegion({
reducer: ee.Reducer.mean(),
geometry: feature.geometry(),
scale: 500
})).set({
time: image.date().millis(),
date: image.date().format()
}).copyProperties(feature);
});
}).flatten();
print(data.first());
// Option 3: for-loop (WATCH OUT!)
var size = countriesTable.size();
// print(size); // 312
var countriesList = countriesTable.toList(1); // Adjust size.
var data = ee.FeatureCollection([]); // Empty table.
for (var j=0; j<1; j++) { // Adjust size.
var feature = ee.Feature(countriesList.get(j));
// Convert ImageCollection > FeatureCollection
var fc = ee.FeatureCollection(imagery.map(function(image) {
return ee.Feature(feature.geometry().centroid(100),
image.reduceRegion({
reducer: ee.Reducer.mean(),
geometry: feature.geometry(),
scale: 500
})).set({
time: image.date().millis(),
date: image.date().format()
}).copyProperties(feature);
}));
data = data.merge(fc);
}
print(data.first());
שימו לב שהדבר first() מכל אוסף מודפס, למטרות ניפוי באגים. אל תצפו שהתוצאה המלאה תהיה זמינה באופן אינטראקטיבי: תצטרכו Export. חשוב גם לזכור שצריך להשתמש בלולאות for בזהירות רבה ורק כמוצא אחרון. לבסוף, לולאת for דורשת לקבל באופן ידני את הגודל של אוסף הקלט ולהגדיר אותו במיקומים המתאימים. אם משהו לא ברור, אל תשתמשו בלולאת for.
שימוש בהפרש קדימה לשכנים בזמן
נניח שיש לכם ImageCollection שממוינת לפי זמן (כלומר, סדרת זמן) ואתם רוצים להשוות כל תמונה לתמונה הקודמת (או הבאה). במקום להשתמש ב-iterate() למטרה הזו, יכול להיות שיעיל יותר להשתמש בהפרש קדמי מבוסס-מערך. בדוגמה הבאה נעשה שימוש בשיטה הזו כדי להסיר כפילויות מאוסף Sentinel-2, כאשר כפילויות מוגדרות כתמונות עם אותו יום בשנה:
var sentinel2 = ee.ImageCollection('COPERNICUS/S2_HARMONIZED');
var sf = ee.Geometry.Point([-122.47555371521855, 37.76884708376152]);
var s2 = sentinel2
.filterBounds(sf)
.filterDate('2018-01-01', '2019-12-31');
var withDoys = s2.map(function(image) {
var ndvi = image.normalizedDifference(['B4', 'B8']).rename('ndvi');
var date = image.date();
var doy = date.getRelative('day', 'year');
var time = image.metadata('system:time_start');
var doyImage = ee.Image(doy)
.rename('doy')
.int();
return ndvi.addBands(doyImage).addBands(time)
.clip(image.geometry()); // Appropriate use of clip.
});
var array = withDoys.toArray();
var timeAxis = 0;
var bandAxis = 1;
var dedupe = function(array) {
var time = array.arraySlice(bandAxis, -1);
var sorted = array.arraySort(time);
var doy = sorted.arraySlice(bandAxis, -2, -1);
var left = doy.arraySlice(timeAxis, 1);
var right = doy.arraySlice(timeAxis, 0, -1);
var mask = ee.Image(ee.Array([[1]]))
.arrayCat(left.neq(right), timeAxis);
return array.arrayMask(mask);
};
var deduped = dedupe(array);
// Inspect these outputs to confirm that duplicates have been removed.
print(array.reduceRegion('first', sf, 10));
print(deduped.reduceRegion('first', sf, 10));
בודקים את האוספים המודפסים כדי לוודא שהעותקים הכפולים הוסרו.