Best practice di codifica

Questo documento descrive le pratiche di programmazione destinate a massimizzare le possibilità di successo di calcoli complessi o costosi di Earth Engine. I metodi descritti qui sono applicabili sia ai calcoli interattivi (ad es. Editor di codice) sia a quelli batch (Export), anche se in genere i calcoli a lunga esecuzione devono essere eseguiti nel sistema batch.

Evita di combinare funzioni e oggetti lato client con funzioni e oggetti lato server

Gli oggetti server di Earth Engine sono oggetti con costruttori che iniziano con ee (ad es. ee.Image, ee.Reducer) e tutti i metodi su questi oggetti sono funzioni server. Qualsiasi oggetto non costruito in questo modo è un oggetto client. Gli oggetti client possono provenire dall'editor di codice (ad es. Map, Chart) o dal linguaggio JavaScript (ad es. Date, Math, [], {}).

Per evitare comportamenti indesiderati, non combinare funzioni client e server nello script, come descritto qui, qui e qui. Consulta questa pagina e/o questo tutorial per una spiegazione approfondita della differenza tra client e server in Earth Engine. L'esempio seguente illustra i pericoli della combinazione di funzionalità client e server:

Errore: questo codice non funziona.

var table = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017');

// Won't work.
for(var i=0; i<table.size(); i++) {
  print('No!');
}

Riesci a individuare l'errore? Tieni presente che table.size() è un metodo lato server su un oggetto lato server e non può essere utilizzato con funzionalità lato client come la condizione <.

Una situazione in cui potresti voler utilizzare i cicli for è la configurazione della UI, poiché gli oggetti e i metodi ui dell'editor di codice sono lato client. (Scopri di più sulla creazione di interfacce utente in Earth Engine). Ad esempio:

Utilizza le funzioni client per la configurazione della UI.

var panel = ui.Panel();
for(var i=1; i<8; i++) {
  panel.widgets().set(i, ui.Button('button ' + i))
}
print(panel);

Al contrario, map() è una funzione lato server e la funzionalità lato client non funzionerà all'interno della funzione passata a map(). Ad esempio:

Errore: questo codice non funziona.

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.
});

Per eseguire un'operazione su ogni elemento di una raccolta, map() una funzione sulla raccolta e set() una proprietà:

Usa map() e 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());

Puoi anche filter() la raccolta in base a proprietà calcolate o esistenti e print() il risultato. Tieni presente che non puoi stampare una raccolta con più di 5000 elementi. Se ricevi l'errore "Query di raccolta interrotta dopo l'accumulo di oltre 5000 elementi", filter() o limit() la raccolta prima di stamparla.

Evita di convertire in elenco se non è necessario

Le raccolte in Earth Engine vengono elaborate utilizzando ottimizzazioni che vengono interrotte convertendo la raccolta in un tipo List o Array. A meno che tu non abbia bisogno di un accesso casuale agli elementi della raccolta (ovvero se devi ottenere l'i-esimo elemento di una raccolta), utilizza i filtri sulla raccolta per accedere ai singoli elementi della raccolta. L'esempio seguente illustra la differenza tra la conversione del tipo (non consigliata) e il filtro (consigliato) per accedere a un elemento di una raccolta:

Non convertire in elenco se non è necessario.

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.

Tieni presente che puoi facilmente attivare errori convertendo una raccolta in un elenco non necessario. Il modo più sicuro è utilizzare filter():

Utilizza filter()!

print(table.filter(ee.Filter.eq('country_na', 'Niger')).first());

Tieni presente che devi utilizzare i filtri il prima possibile nell'analisi.

Evita ee.Algorithms.If()

Non utilizzare ee.Algorithms.If() per implementare la logica di diramazione, soprattutto in una funzione mappata. Come illustrato nell'esempio seguente, ee.Algorithms.If() può richiedere molta memoria e non è consigliato:

Non utilizzare 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.

Tieni presente che il secondo argomento di map() è true. Ciò significa che la funzione mappata potrebbe restituire valori null, che verranno eliminati nella raccolta risultante. Questo può essere utile (senza If()), ma qui la soluzione più semplice è utilizzare un filtro:

Utilizza filter()!

print(table.filter(ee.Filter.eq('country_na', 'Chad')));

Come mostrato in questo tutorial, un approccio di programmazione funzionale che utilizza i filtri è il modo corretto per applicare una logica ad alcuni elementi di una raccolta e un'altra logica agli altri elementi della raccolta.

Evita reproject()

Non utilizzare la riproiezione se non è assolutamente necessario. Un motivo per cui potresti voler utilizzare reproject() è forzare i calcoli dell'editor di codice in modo che vengano eseguiti su una scala specifica, in modo da poter esaminare i risultati sulla scala di analisi che preferisci. Nell'esempio successivo, vengono calcolate le patch di pixel caldi e il numero di pixel in ogni patch. Esegui l'esempio e fai clic su una delle patch. Tieni presente che il conteggio dei pixel è diverso tra i dati riproiettati e quelli non riproiettati.

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);

Il motivo della discrepanza è che la scala di analisi è impostata dal livello di zoom dell'editor di codice. Chiamando reproject(), imposti la scala del calcolo anziché l'editor di codice. Utilizza reproject() con estrema cautela per i motivi descritti in questo documento.

Filtra e select() prima

In generale, filtra le raccolte di input in base a ora, posizione e/o metadati prima di eseguire qualsiasi altra operazione con la raccolta. Applica filtri più selettivi prima di quelli meno selettivi. I filtri spaziali e/o temporali sono spesso più selettivi. Ad esempio, tieni presente che select() e filter() vengono applicati prima di 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');

Utilizza updateMask() anziché mask()

La differenza tra updateMask() e mask() è che il primo esegue un'operazione and() logica dell'argomento (la nuova maschera) e della maschera dell'immagine esistente, mentre mask() sostituisce semplicemente la maschera dell'immagine con l'argomento. Il pericolo di quest'ultimo è che puoi mostrare i pixel involontariamente. In questo esempio, l'obiettivo è mascherare i pixel con un'altitudine inferiore o uguale a 300 metri. Come puoi vedere (riduci lo zoom), l'utilizzo di mask() fa sì che molti pixel vengano mostrati, pixel che non appartengono all'immagine di interesse:

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);

Combina i reducer

Se hai bisogno di più statistiche (ad es. media e deviazione standard) da un singolo input (ad es. una regione dell'immagine), è più efficiente combinare i riduttori. Ad esempio, per ottenere statistiche sulle immagini, combina i riduttori come segue:

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');

In questo esempio, tieni presente che il riduttore della media è combinato con il riduttore della deviazione standard e sharedInputs è true per consentire un singolo passaggio attraverso i pixel di input. Nel dizionario di output, il nome del riduttore viene aggiunto al nome della banda. Per ottenere immagini di media e deviazione standard (ad esempio per normalizzare l'immagine di input), puoi trasformare i valori in un'immagine e utilizzare le espressioni regolari per estrarre singolarmente le medie e le deviazioni standard, come mostrato nell'esempio.

Utilizza Export

I calcoli che generano errori "Limite di memoria utente superato" o "Timeout del calcolo" nell'editor di codice potrebbero essere eseguiti correttamente utilizzando Export. Questo perché i timeout sono più lunghi e il footprint della memoria consentito è maggiore quando l'esecuzione avviene nel sistema batch (dove vengono eseguite le esportazioni). (Esistono altri approcci che potresti voler provare prima, come descritto nel documento di debug). Continuando con l'esempio precedente, supponiamo che il dizionario abbia restituito un errore. Potresti ottenere i risultati con un'operazione simile a questa:

var link = '86836482971a35a5e735a17e93c23272';
Export.table.toDrive({
  collection: ee.FeatureCollection([ee.Feature(null, stats)]),
  description: 'exported_stats_demo_' + link,
  fileFormat: 'CSV'
});

Tieni presente che il link è incorporato nel nome dell'asset, per la riproducibilità. Tieni presente anche che se vuoi esportare toAsset, devi fornire una geometria, che può essere qualsiasi cosa, ad esempio il baricentro dell'immagine, che è piccolo ed economico da calcolare. (ovvero non utilizzare una geometria complessa se non è necessaria).

Consulta la pagina di debug per esempi di utilizzo di Export per risolvere i problemi Timeout del calcolo e Troppe aggregazioni simultanee. Per informazioni dettagliate sull'esportazione in generale, consulta questo documento.

Se non hai bisogno di ritagliare, non utilizzare clip()

L'utilizzo non necessario di clip() aumenterà il tempo di calcolo. Evita clip(), a meno che non sia necessario per l'analisi. Se non hai la certezza, non creare il clip. Esempio di utilizzo errato di un clip:

Non tagliare gli input inutilmente.

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);

Il ritaglio delle immagini di input può essere saltato completamente, perché la regione è specificata nella chiamata reduceRegion():

Specifica la regione per l'output.

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);

Se questo calcolo va in timeout, Export come in questo esempio.

Se devi eseguire il ritaglio con una raccolta complessa, utilizza clipToCollection()

Se hai davvero bisogno di ritagliare qualcosa e le geometrie che vuoi utilizzare per il ritaglio si trovano in una raccolta, utilizza 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);

NON utilizzare featureCollection.geometry() o featureCollection.union() su raccolte di grandi dimensioni e/o complesse, che possono richiedere un utilizzo più intensivo della memoria.

Non utilizzare una raccolta complessa come regione per un riduttore

Se devi eseguire una riduzione spaziale in modo che il riduttore raggruppi gli input di più regioni in un FeatureCollection, non fornire featureCollection.geometry() come input geometry al riduttore. Utilizza invece clipToCollection() e una regione abbastanza grande da comprendere i limiti della raccolta. Ad esempio:

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.

Utilizza un valore errorMargin diverso da zero

Per operazioni di geometria potenzialmente costose, utilizza il margine di errore più ampio possibile in base alla precisione richiesta del calcolo. Il margine di errore specifica l'errore massimo consentito (in metri) durante le operazioni sulle geometrie (ad esempio durante la riproiezione). La specifica di un margine di errore ridotto può comportare la necessità di densificare le geometrie (con coordinate), il che può richiedere molta memoria. È buona norma specificare un margine di errore il più ampio possibile per il calcolo:

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');

Non utilizzare una scala ridicolmente piccola con reduceToVectors()

Se vuoi convertire un raster in un vettore, utilizza una scala appropriata. La specifica di una scala molto piccola può aumentare notevolmente il costo di calcolo. Imposta la scala sul valore più alto possibile per ottenere la precisione richiesta. Ad esempio, per ottenere poligoni che rappresentano le masse terrestri globali:

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');

Nell'esempio precedente, tieni presente l'uso di un poligono non geodetico da utilizzare nelle riduzioni globali.

Non utilizzare reduceToVectors() con reduceRegions()

Non utilizzare un FeatureCollection restituito da reduceToVectors() come input per reduceRegions(). Aggiungi invece le bande che vuoi ridurre prima di chiamare 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));

Tieni presente che altri modi per ridurre i pixel di un'immagine all'interno delle zone di un'altra includono reduceConnectedCommponents() e/o i riduttori di raggruppamento.

Utilizza fastDistanceTransform() per le operazioni di vicinato

Per alcune operazioni di convoluzione, fastDistanceTransform() potrebbe essere più efficiente di reduceNeighborhood() o convolve(). Ad esempio, per eseguire l'erosione e/o la dilatazione degli input binari:

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');

Utilizza le ottimizzazioni in reduceNeighborhood()

Se devi eseguire una convoluzione e non puoi utilizzare fastDistanceTransform(), utilizza le ottimizzazioni in 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');

Non campionare più dati del necessario

Resisti alla tentazione di aumentare inutilmente le dimensioni del set di dati di addestramento. Sebbene l'aumento della quantità di dati di addestramento sia una strategia di machine learning efficace in alcune circostanze, può anche aumentare i costi di calcolo senza un corrispondente aumento dell'accuratezza. (Per capire quando aumentare le dimensioni del set di dati di addestramento, consulta questo riferimento). L'esempio seguente mostra come la richiesta di troppi dati di addestramento possa generare il temuto errore "Il valore calcolato è troppo grande":

Non campionare troppi dati

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

L'approccio migliore è iniziare con una quantità moderata di dati e ottimizzare gli iperparametri del classificatore per determinare se è possibile ottenere l'accuratezza desiderata:

Ottimizza gli iperparametri

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
}));

In questo esempio, il classificatore è già molto accurato, quindi non c'è molto da ottimizzare. Potresti scegliere l'albero più piccolo possibile (ovvero il valore minLeafPopulation più grande) che abbia comunque l'accuratezza richiesta.

Export risultato intermedio

Supponiamo che il tuo obiettivo sia prelevare campioni da un'immagine calcolata relativamente complessa. Spesso è più efficiente Export l'immagine toAsset(), caricare l'immagine esportata e poi campionare. Ad esempio:

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...

In questo esempio, tieni presente che le immagini vengono esportate come valori con rappresentazione in virgola mobile. Non esportare con precisione doppia, a meno che non sia assolutamente necessario. Quando esegui questa esportazione, tieni presente che un link all'editor di codice (ottenuto immediatamente prima dell'esportazione) è incorporato nel nome file per la riproducibilità.

Al termine dell'esportazione, ricarica l'asset e procedi con il campionamento. Tieni presente che, per il debug, viene eseguito prima un campione molto piccolo su un'area di test molto piccola. Se l'operazione va a buon fine, prendi un campione più grande ed esportalo. In genere, questi campioni di grandi dimensioni devono essere esportati. Non aspettarti che questi esempi siano disponibili in modo interattivo (ad esempio tramite print()) o utilizzabili (ad esempio come input per un classificatore) senza prima esportarli.

Join e map-filter

Supponiamo che tu voglia unire le raccolte in base all'ora, alla località o a una proprietà dei metadati. In genere, questa operazione viene eseguita in modo più efficiente con un join. L'esempio seguente esegue un join spazio-temporale tra le raccolte Landsat 8 e 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);

Anche se dovresti provare prima un join (Export se necessario), a volte anche un filter() all'interno di un map() può essere efficace, in particolare per raccolte molto grandi.

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() vs reduceRegions() vs ciclo for

La chiamata di reduceRegions() con un FeatureCollection molto grande o complesso come input potrebbe generare il temuto errore "Il valore calcolato è troppo grande". Una possibile soluzione è mappare reduceRegion() su FeatureCollection. Un'altra potenziale soluzione è utilizzare un ciclo for. Sebbene questa pratica sia fortemente sconsigliata in Earth Engine, come descritto in Map (what to do instead of a for-loop), Functional programming concepts e Loop, reduceRegion() può essere implementato in un ciclo for per eseguire riduzioni di grandi dimensioni.

Supponiamo che il tuo obiettivo sia ottenere la media dei pixel (o qualsiasi statistica) in ogni elemento di una FeatureCollection per ogni immagine di una ImageCollection. L'esempio seguente mette a confronto i tre approcci descritti in precedenza:

// 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());

Tieni presente che l'elemento first() di ogni raccolta viene stampato per scopi di debug. Non dovresti aspettarti che il risultato completo sia disponibile in modo interattivo: dovrai Export. Tieni presente inoltre che i cicli for devono essere utilizzati con estrema cautela e solo come ultima risorsa. Infine, il ciclo for richiede di ottenere manualmente le dimensioni della raccolta di input e di impostarle come hardcoded nelle posizioni appropriate. Se qualcosa non ti è chiaro, non utilizzare un ciclo for.

Utilizza la differenziazione in avanti per i vicini nel tempo

Supponiamo di avere una ImageCollection ordinata temporalmente (ovvero una serie temporale) e di voler confrontare ogni immagine con quella precedente (o successiva). Anziché utilizzare iterate() a questo scopo, potrebbe essere più efficiente utilizzare una differenziazione in avanti basata su array. L'esempio seguente utilizza questo metodo per deduplicare la raccolta Sentinel-2, in cui i duplicati sono definiti come immagini con lo stesso giorno dell'anno:

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));

Esamina le raccolte stampate per verificare che i duplicati siano stati rimossi.