Kodlamayla ilgili en iyi uygulamalar

Bu dokümanda, karmaşık veya pahalı Earth Engine hesaplamalarının başarı şansını en üst düzeye çıkarmayı amaçlayan kodlama uygulamaları açıklanmaktadır. Burada açıklanan yöntemler hem etkileşimli (ör. Kod Düzenleyici) hem de toplu (Export) hesaplamalar için geçerlidir ancak genellikle uzun süren hesaplamalar toplu sistemde çalıştırılmalıdır.

İstemci işlevlerini ve nesnelerini sunucu işlevleri ve nesneleriyle karıştırmaktan kaçının.

Earth Engine sunucu nesneleri, ee ile başlayan kuruculara sahip nesnelerdir (ör. ee.Image, ee.Reducer) ve bu nesnelerdeki tüm yöntemler sunucu işlevleridir. Bu şekilde oluşturulmayan tüm nesneler istemci nesnesidir. İstemci nesneleri, Kod Düzenleyici'den (ör. Map, Chart) veya JavaScript dilinden (ör. Date, Math, [], {}) gelebilir.

İstenmeyen davranışlardan kaçınmak için komut dosyanızda istemci ve sunucu işlevlerini burada, burada ve burada açıklandığı gibi karıştırmayın. Earth Engine'da istemci ve sunucu arasındaki farkların ayrıntılı açıklaması için bu sayfayı ve/veya bu eğitimi inceleyin. Aşağıdaki örnekte, istemci ve sunucu işlevlerini karıştırmanın tehlikeleri gösterilmektedir:

Hata: Bu kod çalışmıyor.

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

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

Hatayı fark edebiliyor musunuz? table.size(), bir sunucu nesnesindeki sunucu yöntemidir ve < koşullu ifadesi gibi istemci tarafı işlevleriyle kullanılamaz.

Kod Düzenleyici ui nesneleri ve yöntemleri istemci tarafında olduğundan, for döngülerini kullanıcı arayüzü kurulumunda kullanmak isteyebilirsiniz. Earth Engine'da kullanıcı arayüzleri oluşturma hakkında daha fazla bilgi edinin. Örneğin:

Kullanıcı arayüzü kurulumu için istemci işlevlerini kullanın.

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

Buna karşılık, map() bir sunucu işlevidir ve istemci işlevleri, map() işlevine iletilen işlevin içinde çalışmaz. Örneğin:

Hata: Bu kod çalışmıyor.

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

Bir koleksiyondaki her öğe üzerinde işlem yapmak için koleksiyon üzerinde bir işlevi map() ve bir özelliği set():

map() ve set() kullanın!

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

Ayrıca, hesaplanan veya mevcut özelliklere göre koleksiyonu filter() ve sonucu print(). 5.000'den fazla öğe içeren bir koleksiyonu yazdıramayacağınızı unutmayın. "Collection query aborted after accumulating over 5000 elements" (5.000'den fazla öğe biriktirildikten sonra koleksiyon sorgusu iptal edildi) hatasını alırsanız yazdırmadan önce koleksiyonu filter() veya limit().

Gereksiz yere listeye dönüştürmekten kaçının

Earth Engine'deki koleksiyonlar, koleksiyonu List veya Array türüne dönüştürerek bozulan optimizasyonlar kullanılarak işlenir. Koleksiyon öğelerine rastgele erişmeniz gerekmiyorsa (ör. bir koleksiyonun i'inci öğesini almanız gerekmiyorsa) tek tek koleksiyon öğelerine erişmek için koleksiyonda filtreler kullanın. Aşağıdaki örnekte, bir koleksiyondaki öğeye erişmek için tür dönüştürme (önerilmez) ile filtreleme (önerilir) arasındaki fark gösterilmektedir:

Gereksiz yere listeye dönüştürmeyin.

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.

Bir koleksiyonu gereksiz yere listeye dönüştürerek kolayca hata tetikleyebileceğinizi unutmayın. Daha güvenli bir yöntem olarak filter() kullanabilirsiniz:

filter() kullanın!

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

Analizinizde filtreleri mümkün olduğunca erken kullanmanız gerektiğini unutmayın.

ee.Algorithms.If() kullanmayın

Özellikle eşlenen bir işlevde dallanma mantığını uygulamak için ee.Algorithms.If() kullanmayın. Aşağıdaki örnekte gösterildiği gibi, ee.Algorithms.If() yoğun bellek kullanımı gerektirebilir ve önerilmez:

If() kullanmayın!

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() için ikinci bağımsız değişkenin true olduğunu unutmayın. Bu, eşlenen işlevin boş değerler döndürebileceği ve bu değerlerin sonuç koleksiyonundan çıkarılacağı anlamına gelir. Bu yöntem (If() olmadan) faydalı olabilir ancak buradaki en kolay çözüm bir filtre kullanmaktır:

filter() kullanın!

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

Bu eğitimde gösterildiği gibi, bir koleksiyonun bazı öğelerine bir mantık, diğer öğelerine başka bir mantık uygulamak için filtreleri kullanan işlevsel bir programlama yaklaşımı doğru yöntemdir.

reproject() kullanmayın

Kesinlikle gerekli olmadıkça yeniden projeksiyon kullanmayın. reproject() kullanmak istemenizin bir nedeni, Kod Düzenleyici hesaplamalarını belirli bir ölçekte gerçekleşmeye zorlamak olabilir. Böylece sonuçları istediğiniz analiz ölçeğinde inceleyebilirsiniz. Sonraki örnekte, sıcak piksel grupları ve her gruptaki piksel sayısı hesaplanır. Örneği çalıştırın ve yamalardan birini tıklayın. Yeniden projeksiyonu yapılan veriler ile yapılmayan veriler arasında piksel sayısının farklı olduğunu unutmayın.

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

Bu tutarsızlığın nedeni, analiz ölçeğinin Kod Düzenleyici yakınlaştırma seviyesine göre ayarlanmasıdır. Kod Düzenleyici yerine reproject() işlevini çağırarak hesaplamanın ölçeğini ayarlarsınız. Bu dokümanda açıklanan nedenlerden dolayı reproject() aracını çok dikkatli kullanın.

Önce filtreleyin ve select()

Genel olarak, koleksiyonla başka bir işlem yapmadan önce giriş koleksiyonlarını zamana, konuma ve/veya meta verilere göre filtreleyin. Daha seçici filtreleri daha az seçici filtrelerden önce uygulayın. Mekansal ve/veya zamansal filtreler genellikle daha seçicidir. Örneğin, select() ve filter(), map()'den önce uygulanır:

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

mask() yerine updateMask() kullanın

updateMask() ile mask() arasındaki fark, ilkinin bağımsız değişken (yeni maske) ve mevcut resim maskesi için mantıksal and() işlemi yapması, mask() işlevinin ise resim maskesini bağımsız değişkenle değiştirmesidir. İkincisinin tehlikesi, piksellerin maskesini istemeden kaldırabilmenizdir. Bu örnekte amaç, 300 metre veya daha düşük yükseklikteki pikselleri maskelemektir. Gördüğünüz gibi (uzaklaştırın), mask() kullanıldığında, ilgili görüntüye ait olmayan birçok pikselin maskesi kaldırılır:

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

Redüktörleri birleştirme

Tek bir girişten (ör. bir görüntü bölgesi) birden fazla istatistiğe (ör. ortalama ve standart sapma) ihtiyacınız varsa indirgeyicileri birleştirmek daha verimlidir. Örneğin, görüntü istatistiklerini almak için azaltıcıları aşağıdaki gibi birleştirin:

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

Bu örnekte, ortalama azaltıcının standart sapma azaltıcıyla birleştirildiğini ve giriş pikselleri üzerinden tek bir geçişi etkinleştirmek için sharedInputs değerinin doğru olduğunu unutmayın. Çıkış sözlüğünde, indirgeyicinin adı bant adına eklenir. Ortalama ve standart sapma görüntülerini elde etmek için (örneğin, giriş görüntüsünü normalleştirmek için) değerleri bir görüntüye dönüştürebilir ve örnekte gösterildiği gibi ortalamaları ve standart sapmaları ayrı ayrı çıkarmak için normal ifadeler kullanabilirsiniz.

Export hareketini kullanın

Kod Düzenleyici'de "Kullanıcı bellek sınırı aşıldı" veya "Hesaplama zaman aşımına uğradı" hatalarına neden olan hesaplamalar, Export kullanılarak başarıyla tamamlanabilir. Bunun nedeni, toplu sistemde (dışa aktarma işlemlerinin çalıştığı yer) çalışırken zaman aşımlarının daha uzun ve izin verilen bellekte kaplanan yerin daha fazla olmasıdır. (Hata ayıklama belgesinde ayrıntılı olarak açıklandığı gibi, önce denemek isteyebileceğiniz başka yaklaşımlar da vardır). Önceki örneğe devam edecek olursak sözlüğün bir hata döndürdüğünü varsayalım. Sonuçları şu şekilde elde edebilirsiniz:

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

Yeniden üretilebilirlik için bağlantının öğe adına yerleştirildiğini unutmayın. Ayrıca, toAsset dışa aktarmak istiyorsanız bir geometri sağlamanız gerekir. Bu geometri, küçük ve hesaplaması kolay olan görüntü ağırlık merkezi gibi herhangi bir şey olabilir. (Örneğin, ihtiyacınız yoksa karmaşık bir geometri kullanmayın.)

Hesaplama zaman aşımına uğradı ve Çok fazla eşzamanlı toplama var hatalarını çözmek için Export kullanma örneklerini hata ayıklama sayfasında bulabilirsiniz. Genel olarak dışa aktarma hakkında ayrıntılı bilgi için bu belgeyi inceleyin.

Kırpmanız gerekmiyorsa clip() kullanmayın

clip() işlevini gereksiz yere kullanmak hesaplama süresini artırır. Analiziniz için gerekli olmadığı sürece clip() kullanmaktan kaçının. Emin değilseniz klip oluşturmayın. Klibin kötü kullanımına bir örnek:

Girişleri gereksiz yere kırpmayın.

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

Bölge, reduceRegion() çağrısında belirtildiğinden giriş resimlerini kırpma işlemi tamamen atlanabilir:

Çıkış için bölgeyi belirtin.

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

Bu hesaplama zaman aşımına uğrarsa bu örnekte olduğu gibi Export.

Karmaşık bir koleksiyonla kırpmanız gerekiyorsa clipToCollection() kullanın.

Bir şeyi gerçekten kırpmanız gerekiyorsa ve kırpma için kullanmak istediğiniz geometriler bir koleksiyondaysa clipToCollection() kullanın:

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

Daha fazla bellek kullanımı gerektirebilecek büyük ve/veya karmaşık koleksiyonlarda featureCollection.geometry() veya featureCollection.union() kullanmayın.

Bir indirgeyicinin bölgesi olarak karmaşık bir koleksiyon kullanmayın.

İndirgeyicinin bir FeatureCollection içindeki birden fazla bölgeden girişleri birleştireceği şekilde bir mekansal indirgeme yapmanız gerekiyorsa indirgeyiciye geometry girişi olarak featureCollection.geometry() sağlamayın. Bunun yerine clipToCollection() ve koleksiyonun sınırlarını kapsayacak kadar büyük bir bölge kullanın. Örneğin:

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.

Sıfır olmayan bir errorMargin kullanın.

Maliyetli olabilecek geometri işlemleri için hesaplamanın gerekli hassasiyetine göre mümkün olan en büyük hata payını kullanın. Hata payı, geometrilerle ilgili işlemler sırasında (ör. yeniden projeksiyon sırasında) izin verilen maksimum hatayı (metre cinsinden) belirtir. Küçük bir hata payı belirtmek, geometrileri (koordinatlarla) yoğunlaştırma ihtiyacına yol açabilir. Bu da bellek açısından yoğun olabilir. Hesaplamanız için mümkün olduğunca büyük bir hata payı belirtmek iyi bir uygulamadır:

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() ile çok küçük bir ölçek kullanmayın

Bir rasterı vektöre dönüştürmek istiyorsanız uygun bir ölçek kullanın. Çok küçük bir ölçek belirtmek, hesaplama maliyetini önemli ölçüde artırabilir. Ölçeği, gerekli hassasiyeti sağlayacak şekilde mümkün olduğunca yüksek ayarlayın. Örneğin, dünya üzerindeki kara kütlelerini temsil eden poligonları almak için:

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

Önceki örnekte, global azaltmalarda kullanılmak üzere jeodezik olmayan bir poligonun kullanıldığına dikkat edin.

reduceToVectors() uygulamasını reduceRegions() ile kullanma

reduceToVectors() tarafından döndürülen bir FeatureCollection değerini reduceRegions() için giriş olarak kullanmayın. Bunun yerine, reduceToVectors() işlevini çağırmadan önce azaltmak istediğiniz bantları ekleyin:

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

Bir görüntünün piksellerini başka bir görüntünün bölgeleri içinde azaltmanın diğer yolları arasında reduceConnectedCommponents() ve/veya gruplandırma azaltıcılar yer alır.

Mahalle işlemleri için fastDistanceTransform() kullanın

Bazı evrişim işlemleri için fastDistanceTransform(), reduceNeighborhood() veya convolve()'den daha verimli olabilir. Örneğin, ikili girişlerin aşınmasını ve/veya genişlemesini yapmak için:

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() uygulamasındaki optimizasyonları kullanma

Evrişim gerçekleştirmeniz gerekiyorsa ve fastDistanceTransform() işlevini kullanamıyorsanız reduceNeighborhood() işlevindeki optimizasyonları kullanın.

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

İhtiyacınız olandan daha fazla veri örneklemeyin

Eğitim veri kümenizin boyutunu gereksiz yere artırmaktan kaçının. Eğitim verilerinin miktarını artırmak bazı durumlarda etkili bir makine öğrenimi stratejisi olsa da doğrulukta bir artış olmadan hesaplama maliyetini de artırabilir. (Eğitim veri kümesi boyutunun ne zaman artırılacağını anlamak için bu referansa bakın). Aşağıdaki örnekte, çok fazla eğitim verisi istemenin korkunç "Hesaplanan değer çok büyük" hatasına nasıl yol açabileceği gösterilmektedir:

Çok fazla veri örneklemeyin.

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

Daha iyi bir yaklaşım, orta miktarda veriyle başlayıp sınıflandırıcının hiperparametrelerini ayarlayarak istediğiniz doğruluğa ulaşıp ulaşamayacağınızı belirlemektir:

Hiperparametreleri ayarlayın.

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

Bu örnekte sınıflandırıcı zaten çok doğru sonuçlar verdiğinden fazla ayarlama yapılmasına gerek yoktur. Gerekli doğruluğa sahip en küçük ağacı (yani en büyük minLeafPopulation) seçmek isteyebilirsiniz.

Export ara sonuç

Amacınızın nispeten karmaşık bir hesaplanmış görüntüden örnekler almak olduğunu varsayalım. Görüntüyü Export toAsset(), dışa aktarılan görüntüyü yüklemek ve ardından örneklemek genellikle daha verimlidir. Örneğin:

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

Bu örnekte, görüntülerin kayan nokta olarak dışa aktarıldığına dikkat edin. Kesinlikle gerekli olmadığı sürece çift duyarlılıkla dışa aktarmayın. Bu dışa aktarma işlemini yaparken, tekrarlanabilirlik için dosya adına bir Kod Düzenleyici bağlantısının (dışa aktarmadan hemen önce elde edilir) yerleştirildiğini unutmayın.

Dışa aktarma işlemi tamamlandıktan sonra öğeyi yeniden yükleyin ve öğeden örnekleme yapmaya devam edin. Hata ayıklama için önce çok küçük bir test alanında çok küçük bir örnek çalıştırılır. Bu işlemin başarılı olduğu görüldüğünde daha büyük bir örnek alıp dışa aktarın. Bu kadar büyük örneklerin genellikle dışa aktarılması gerekir. Bu örneklerin etkileşimli olarak (örneğin, print() aracılığıyla) kullanılabilir veya kullanılabilir (örneğin, bir sınıflandırıcıya giriş olarak) olmasını beklemeyin.

Join vs. map-filter

Koleksiyonları zamana, konuma veya bir meta veri özelliğine göre birleştirmek istediğinizi varsayalım. Genellikle bu işlem en verimli şekilde bir birleşimle gerçekleştirilir. Aşağıdaki örnekte, Landsat 8 ve Sentinel-2 koleksiyonları arasında uzamsal-zamansal bir birleştirme işlemi gerçekleştirilmektedir:

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

Öncelikle birleştirme (gerekirse Export) denemeniz gerekse de bazen map() içinde filter() de etkili olabilir. Bu, özellikle çok büyük koleksiyonlar için geçerlidir.

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() ve for döngüsü karşılaştırması

reduceRegions() işlevini çok büyük veya karmaşık bir FeatureCollection ile giriş olarak çağırmak, korkunç "Hesaplanan değer çok büyük" hatasına neden olabilir. Olası çözümlerden biri, reduceRegion() yerine FeatureCollection ile eşleme yapmaktır. Olası bir diğer çözüm de for döngüsü kullanmaktır. Map (for döngüsü yerine ne yapılmalı), İşlevsel programlama kavramları ve Döngü bölümlerinde açıklandığı gibi Earth Engine'de bu yöntem kesinlikle önerilmese de büyük azaltma işlemleri gerçekleştirmek için for döngüsünde reduceRegion() uygulanabilir.

Amacınızın, bir ImageCollection içindeki her görüntü için bir FeatureCollection içindeki her özellikteki piksellerin ortalamasını (veya herhangi bir istatistiği) elde etmek olduğunu varsayalım. Aşağıdaki örnekte, daha önce açıklanan üç yaklaşım karşılaştırılmaktadır:

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

Hata ayıklama amacıyla her koleksiyondaki first() öğenin yazdırıldığına dikkat edin. Sonucun tamamının etkileşimli olarak sunulmasını beklemeyin. Export gerekir. Ayrıca for döngülerinin çok dikkatli ve yalnızca son çare olarak kullanılması gerektiğini unutmayın. Son olarak, for döngüsü, giriş koleksiyonunun boyutunun manuel olarak alınmasını ve uygun konumlarda sabit kodlanmasını gerektirir. Bunlardan herhangi biri size belirsiz geliyorsa for döngüsü kullanmayın.

Zaman içindeki komşular için ileri fark yöntemini kullan

Zamana göre sıralanmış bir ImageCollection (yani zaman serisi) olduğunu ve her görüntüyü önceki (veya sonraki) görüntüyle karşılaştırmak istediğinizi varsayalım. Bu amaçla iterate() kullanmak yerine dizi tabanlı ileri fark alma yöntemini kullanmak daha verimli olabilir. Aşağıdaki örnekte, Sentinel-2 koleksiyonunu tekilleştirmek için bu yöntem kullanılmaktadır. Burada kopyalar, yılın aynı gününe ait görüntüler olarak tanımlanır:

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

Yinelenenlerin kaldırıldığını doğrulamak için yazdırılan koleksiyonları inceleyin.