Guia de depuração

Os algoritmos criados no Earth Engine são executados na nuvem do Google, distribuídos em muitos computadores. A depuração pode ser desafiadora porque os erros podem ocorrer no código do lado do cliente ou na execução do lado do servidor das instruções codificadas e resultar de problemas de escalonamento, bem como de erros sintáticos ou lógicos. Os bits do programa que estão sendo executados em algum lugar na nuvem não estão disponíveis para inspeção, a menos que você solicite. Este documento apresenta estratégias, ferramentas e soluções de depuração para ajudar a resolver erros comuns e depurar scripts do Earth Engine.

Erros de sintaxe

Erros de sintaxe ocorrem quando o código viola as regras da linguagem de programação (JavaScript ou Python no Earth Engine). Esses erros impedem a execução do código e geralmente são detectados antes da execução. Se você encontrar um erro de sintaxe, analise cuidadosamente a linha destacada ou a mensagem de erro e consulte recursos como a Referência da linguagem Python ou o Guia de estilo do JavaScript do Google. Um lintificador de código também pode ajudar a identificar e corrigir esses problemas.

Erros do lado do cliente

Apesar do código estar sintaticamente correto, pode haver erros associados à consistência ou lógica do script. Os exemplos a seguir demonstram erros ao usar uma variável e um método que não existem.

Erro: este código não funciona.

// Load a Sentinel-2 image.
var image = ee.Image('USGS/SRTMGL1_003');

// Error: "bandNames" is not defined in this scope.
var display = image.visualize({bands: bandNames, min: 0, max: 9000});

// Error: image.selfAnalyze is not a function
var silly = image.selfAnalyze();

import ee
import geemap.core as geemap

# Load a Sentinel-2 image.
image = ee.Image('USGS/SRTMGL1_003')

# NameError: name 'band_names' is not defined.
display = image.visualize(bands=band_names, min=0, max=9000)

# AttributeError: 'Image' object has no attribute 'selfAnalyze'.
silly = image.selfAnalyze()

O primeiro erro informa que a variável bandNames não está definida no escopo em que é referenciada. Como solução, defina a variável ou forneça um argumento de lista para o parâmetro bands. O segundo erro demonstra o que acontece quando a função selfAnalyze() inexistente é chamada. Como esse não é um método real em imagens, o erro informa que não é uma função. Em ambos os casos, o erro é descritivo do problema.

Atribuição de tipo de objeto desconhecida

O erro "...is not a function" pode ocorrer porque o Earth Engine não conhece o tipo de uma variável. As manifestações comuns desse problema são resultado de:

• Fazer algo com um objeto retornado por first() (o tipo dos elementos em uma coleção é desconhecido).
• Fazer algo com um objeto retornado por get() (o tipo de elemento armazenado em uma propriedade é desconhecido).
• Fazer algo com um argumento de função (na função) quando o tipo do argumento é desconhecido.

Como exemplo do primeiro:

Erro: este código não funciona.

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

// Error: collection.first(...).area is not a function
var area = collection.first().area();

import ee
import geemap.core as geemap

collection = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017')

# AttributeError: 'Element' object has no attribute 'area'.
area = collection.first().area()

A solução em todos os casos é converter o objeto de tipo desconhecido com o construtor do tipo conhecido. Continuando o exemplo anterior, a solução é converter para ee.Feature:

Solução: use uma transmissão.

var area = ee.Feature(collection.first()).area();

import ee
import geemap.core as geemap

area = ee.Feature(collection.first()).area()

É possível chamar qualquer método em Element aqui com segurança, porque é isso que o Earth Engine considera.

Evitar misturar funções de cliente e servidor

O exemplo a seguir é menos óbvio:

Erro: o código não faz o que você quer.

// Don't mix EE objects and JavaScript objects.
var image = ee.Image('USGS/SRTMGL1_003');
var nonsense = image + 2;

// You can print this, but it's not what you were hoping for.
print(nonsense);

// Error: g.eeObject.name is not a function
Map.addLayer(nonsense);

import ee
import geemap.core as geemap

# Don't mix EE objects and Python objects.
image = ee.Image('USGS/SRTMGL1_003')
nonsense = image + 2

# TypeError: unsupported operand type(s) for +: 'Image' and 'int'.
display(nonsense)

# TypeError: unsupported operand type(s) for +: 'Image' and 'int'.
m = geemap.Map()
m.add_layer(nonsense)
m

Supondo que o autor desse código pretendia adicionar 2 a cada pixel da imagem, essa não é a maneira certa de fazer isso. Especificamente, esse código mistura incorretamente um objeto do lado do servidor (image) com um operador do lado do cliente (+). Os resultados podem ser surpreendentes. No primeiro caso, a impressão de nonsense no editor de código JavaScript vai realizar a operação solicitada (+) convertendo image e 2 em strings e concatenando-as. A string resultante é involuntária (no Python, uma TypeError é gerada). No segundo caso, ao adicionar nonsense ao mapa, o erro g.eeObject.name is not a function criptográfico é exibido no editor de código JavaScript porque o objeto adicionado ao mapa, nonsense, é uma string, não um objeto EE (no Python, um TypeError é gerado). Para evitar resultados não intencionais e erros não informativos, não misture objetos e funções do servidor com objetos, primitivos ou funções do cliente. A solução neste exemplo é usar uma função do servidor.

Solução: use uma função do servidor.

Map.addLayer(image.add(2));

import ee
import geemap.core as geemap

m = geemap.Map()
m.add_layer(image.add(2))
m

Consulte a página Cliente x servidor para mais detalhes.

Bloqueio do navegador do editor de código JavaScript

O congelamento ou travamento do navegador pode ocorrer quando a execução do JavaScript no cliente leva muito tempo ou quando há uma espera por algo do Earth Engine. Duas fontes comuns desse erro são loops for e/ou getInfo() no código do editor de código JavaScript, com o pior cenário de getInfo() dentro de um loop for. Os loops For podem fazer com que o navegador trave porque o código é executado na sua máquina. Por outro lado, getInfo() solicita de forma síncrona o resultado de uma computação do Earth Engine, bloqueando até que o resultado seja recebido. Se a computação demorar muito, o bloqueio poderá fazer com que o navegador trave. Evite loops for e getInfo() ao trabalhar no editor de código. Consulte a página Cliente x servidor para mais detalhes.

Erros do lado do servidor

Apesar da consistência lógica no código do cliente, podem haver bugs que só se tornam aparentes no tempo de execução no servidor. O exemplo a seguir demonstra o que acontece ao tentar acessar uma banda que não existe.

Erro: este código não funciona.

// Load a Sentinel-2 image.
var s2image = ee.Image(
    'COPERNICUS/S2_HARMONIZED/20160625T100617_20160625T170310_T33UVR');

// Error: Image.select: Pattern 'nonBand' did not match any bands.
print(s2image.select(['nonBand']));

import ee
import geemap.core as geemap

# Load a Sentinel-2 image.
s2image = ee.Image(
    'COPERNICUS/S2_HARMONIZED/20160625T100617_20160625T170310_T33UVR'
)

# EEException: Image.select: Band pattern 'non_band' did not match any bands.
print(s2image.select(['non_band']).getInfo())

Neste exemplo, o erro informa que não há uma banda chamada nonBand. A solução mais óbvia é especificar um nome de banda que exista. É possível descobrir os nomes das bandas imprimindo a imagem e inspecionando-a no console ou imprimindo a lista de nomes de bandas retornada por image.bandNames().

Imutabilidade

Os objetos criados no lado do servidor no Earth Engine são immutable. (Qualquer ee.Object é um Object do lado do servidor). Isso significa que, se você quiser fazer uma alteração no objeto, salve o estado alterado em uma nova variável. Por exemplo, esta abordagem não vai funcionar para definir uma propriedade na imagem Sentinel-2:

Erro: esse código não faz o que você quer.

var s2image = ee.Image(
    'COPERNICUS/S2_HARMONIZED/20160625T100617_20160625T170310_T33UVR');
s2image.set('myProperty', 'This image is not assigned to a variable');

// This will not result in an error, but will not find 'myProperty'.
print(s2image.get('myProperty')); // null

import ee
import geemap.core as geemap

s2image = ee.Image(
    'COPERNICUS/S2_HARMONIZED/20160625T100617_20160625T170310_T33UVR'
)
s2image.set('my_property', 'This image is not assigned to a variable')

# This will not result in an error, but will not find 'my_property'.
display(s2image.get('my_property'))  # None

Neste exemplo, s2image.set() retorna uma cópia da imagem com a nova propriedade, mas a imagem armazenada na variável s2image não é alterada. É necessário salvar a imagem retornada por s2image.set() em uma nova variável. Exemplo:

Solução: capture o resultado em uma variável.

s2image = s2image.set('myProperty', 'OK');
print(s2image.get('myProperty')); // OK

import ee
import geemap.core as geemap

s2image = s2image.set('my_property', 'OK')
display(s2image.get('my_property'))  # OK

Funções mapeadas

Outro contexto em que as funções do cliente e do servidor não se misturam é nas funções mapeadas. Especificamente, as operações especificadas pela função mapeada são executadas na nuvem, portanto, funções do cliente, como getInfo e Export, além de print e método em Map e Chart no editor de código JavaScript, não funcionam em funções mapeadas. Exemplo:

Erro: este código não funciona.

var collection = ee.ImageCollection('MODIS/006/MOD44B');

// Error: A mapped function's arguments cannot be used in client-side operations
var badMap3 = collection.map(function(image) {
  print(image);
  return image;
});

import ee
import geemap.core as geemap

collection = ee.ImageCollection('MODIS/006/MOD44B')

# Error: A mapped function's arguments cannot be used in client-side operations.
bad_map_3 = collection.map(lambda image: print(image.getInfo()))

Esse erro um tanto misterioso é resultado do processo que o Earth Engine usa para transformar esse código em um conjunto de instruções que podem ser executadas nos servidores do Google. As funções do lado do cliente e as estruturas de controle não podem ser usadas para operar na imagem do argumento transmitida para a função mapeada. Para evitar esse erro, não use funções do lado do cliente em funções mapeadas. Consulte a página Cliente x servidor para saber mais sobre a distinção entre as funções do cliente e do servidor.

As funções mapeadas têm requisitos adicionais. Por exemplo, as funções mapeadas precisam retornar algo:

Erro: este código não funciona.

var collection = ee.ImageCollection('MODIS/006/MOD44B');

// Error: User-defined methods must return a value.
var badMap1 = collection.map(function(image) {
  // Do nothing.
});

import ee
import geemap.core as geemap

collection = ee.ImageCollection('MODIS/006/MOD44B')

# Error: User-defined methods must return a value.
bad_map_1 = collection.map(lambda image: None)

A solução mais óbvia é devolver o produto. Mas ele não pode retornar qualquer tipo de coisa. Especificamente, as funções mapeadas em um ImageCollection ou FeatureCollection precisam retornar um Image ou Feature. Por exemplo, não é possível retornar uma data de uma função mapeada em um ImageCollection:

Erro: este código não funciona.

var collection = ee.ImageCollection('MODIS/006/MOD44B');

var badMap2 = collection.map(function(image) {
  return image.date();
});

// Error: Collection.map: A mapped algorithm must return a Feature or Image.
print(badMap2);

import ee
import geemap.core as geemap

collection = ee.ImageCollection('MODIS/006/MOD44B')

bad_map_2 = collection.map(lambda image: image.date())

# EEException: Collection.map:
# A mapped algorithm must return a Feature or Image.
print(bad_map_2.getInfo())

Para evitar isso, retorne a imagem de entrada com um novo conjunto de propriedades. Em seguida, se você precisar de uma lista das datas das imagens na coleção, use aggregate_array():

Solução: defina uma propriedade.

var collection = ee.ImageCollection('MODIS/006/MOD44B');

var okMap2 = collection.map(function(image) {
  return image.set('date', image.date());
});
print(okMap2);

// Get a list of the dates.
var datesList = okMap2.aggregate_array('date');
print(datesList);

import ee
import geemap.core as geemap

collection = ee.ImageCollection('MODIS/006/MOD44B')

ok_map_2 = collection.map(lambda image: image.set('date', image.date()))
print(ok_map_2.getInfo())

# Get a list of the dates.
dates_list = ok_map_2.aggregate_array('date')
print(dates_list.getInfo())

Erros procedimentais

O padrão foi aplicado a uma imagem sem faixas

O erro "Pattern 'my_band' was applied to an Image with no bands" significa que há uma chamada ee.Image.select() para uma imagem com uma lista de faixas vazia. Confira o que você pode fazer para resolver esse problema:

• Se a imagem for produzida a partir de uma ImageCollection com um redutor ou usando as chamadas first() ou toBands(), verifique se a coleção de origem não está vazia.
• Se a imagem for produzida a partir de um dicionário usando ee.Dictionary().toImage(), verifique se o dicionário não está vazio.
• Se a imagem for independente, verifique se ela tem dados (e não apenas ee.Image(0)).

Erros de escalonamento

Embora um script possa estar sintaticamente correto, sem erros lógicos, e representar um conjunto válido de instruções para o servidor, ao paralelizar e executar a computação, os objetos resultantes podem ser muito grandes, muito numerosos ou levar muito tempo para serem computados. Nesse caso, você vai receber um erro indicando que o algoritmo não pode ser escalonado. Esses erros geralmente são os mais difíceis de diagnosticar e resolver. Exemplos desse tipo de erro incluem:

• O tempo de computação expirou
• Muitas agregações simultâneas
• Limite de memória do usuário excedido
• Ocorreu um erro interno

Melhorar a escalabilidade do código permite que você obtenha resultados mais rapidamente e também melhora a disponibilidade de recursos de computação para todos os usuários. Cada tipo de erro é discutido nas seções a seguir, após uma breve observação sobre reduceRegion(), uma função usada com frequência que é conhecida por causar todos os tipos de erro de dimensionamento.

reduceRegion()

Embora reduceRegion() consuma muitos pixels para acionar uma variedade de erros, também há parâmetros destinados a controlar a computação, para que você possa superar os erros. Por exemplo, considere a redução inadequada a seguir:

Erro: este código não funciona.

var absurdComputation = ee.Image(1).reduceRegion({
  reducer: 'count',
  geometry: ee.Geometry.Rectangle([-180, -90, 180, 90], null, false),
  scale: 100,
});

// Error: Image.reduceRegion: Too many pixels in the region.
//        Found 80300348117, but only 10000000 allowed.
print(absurdComputation);

import ee
import geemap.core as geemap

absurd_computation = ee.Image(1).reduceRegion(
    reducer='count',
    geometry=ee.Geometry.Rectangle([-180, -90, 180, 90], None, False),
    scale=100,
)

# EEException: Image.reduceRegion: Too many pixels in the region.
#        Found 80300348117, but only 10000000 allowed.
print(absurd_computation.getInfo())

Este exemplo é apenas para demonstração. O objetivo desse erro é perguntar se você realmente quer reduzir 80300348117 (80 bilhões) de pixels. Caso contrário, aumente o scale (tamanho do pixel em metros) de acordo ou defina bestEffort como verdadeiro para recalcular automaticamente uma escala maior. Consulte a página reduceRegion() para mais detalhes sobre esses parâmetros.

O tempo de computação expirou

Suponha que você precise de todos esses pixels na computação. Nesse caso, aumente o parâmetro maxPixels para permitir que a computação seja concluída. No entanto, o Earth Engine vai levar algum tempo para concluir a computação. Como resultado, um erro de "tempo limite de computação" pode ser gerado:

Ruim: não faça isso.

var ridiculousComputation = ee.Image(1).reduceRegion({
  reducer: 'count',
  geometry: ee.Geometry.Rectangle([-180, -90, 180, 90], null, false),
  scale: 100,
  maxPixels: 1e11
});

// Error: Computation timed out.
print(ridiculousComputation);

import ee
import geemap.core as geemap

ridiculous_computation = ee.Image(1).reduceRegion(
    reducer='count',
    geometry=ee.Geometry.Rectangle([-180, -90, 180, 90], None, False),
    scale=100,
    maxPixels=int(1e11),
)

# Error: Computation timed out.
print(ridiculous_computation.getInfo())

Esse erro significa que o Earth Engine esperou cerca de cinco minutos antes de interromper a computação. A exportação permite que o Earth Engine realize a computação em um ambiente com tempos de execução mais longos (mas não mais memória). Como o valor de retorno de reduceRegion() é um dicionário, é possível usar o dicionário para definir as propriedades de um elemento com geometria nula:

Bom: use Export.

Export.table.toDrive({
  collection: ee.FeatureCollection([
    ee.Feature(null, ridiculousComputation)
  ]),
  description: 'ridiculousComputation',
  fileFormat: 'CSV'
});

import ee
import geemap.core as geemap

task = ee.batch.Export.table.toDrive(
    collection=ee.FeatureCollection([ee.Feature(None, ridiculous_computation)]),
    description='ridiculous_computation',
    fileFormat='CSV',
)
# task.start()

Muitas agregações simultâneas

A parte "agregações" desse erro se refere a operações distribuídas em várias máquinas (como reduções que abrangem mais de um bloco). O Earth Engine tem limites para evitar que muitas agregações sejam executadas simultaneamente. Neste exemplo, o erro "Muitas agregações simultâneas" é acionado por uma redução em um mapa:

Ruim: não faça isso.

var collection = ee.ImageCollection('LANDSAT/LT05/C02/T1')
    .filterBounds(ee.Geometry.Point([-123, 43]));

var terribleAggregations = collection.map(function(image) {
  return image.set(image.reduceRegion({
    reducer: 'mean',
    geometry: image.geometry(),
    scale: 30,
    maxPixels: 1e9
  }));
});

// Error: Quota exceeded: Too many concurrent aggregations.
print(terribleAggregations);

import ee
import geemap.core as geemap

collection = ee.ImageCollection('LANDSAT/LT05/C02/T1').filterBounds(
    ee.Geometry.Point([-123, 43])
)


def apply_mean_aggregation(image):
  return image.set(
      image.reduceRegion(
          reducer='mean',
          geometry=image.geometry(),
          scale=30,
          maxPixels=int(1e9),
      )
  )


terrible_aggregations = collection.map(apply_mean_aggregation)

# EEException: Computation timed out.
print(terrible_aggregations.getInfo())

Supondo que o objetivo desse código seja receber estatísticas de imagem para cada imagem, uma solução possível é Export o resultado. Por exemplo, usando o fato de que um ImageCollection também é um FeatureCollection, os metadados associados às imagens podem ser exportados como uma tabela:

Bom: use Export.

Export.table.toDrive({
  collection: terribleAggregations,
  description: 'terribleAggregations',
  fileFormat: 'CSV'
});

import ee
import geemap.core as geemap

task = ee.batch.Export.table.toDrive(
    collection=terrible_aggregations,
    description='terrible_aggregations',
    fileFormat='CSV',
)
# task.start()

Limite de memória do usuário excedido

Uma maneira de paralelizar seus algoritmos no Earth Engine é dividindo as entradas em blocos, executando a mesma computação separadamente em cada bloco e combinando os resultados. Como consequência, todas as entradas necessárias para calcular um Bloco de saída precisam caber na memória. Por exemplo, quando a entrada é uma imagem com muitas bandas, ela pode acabar consumindo muita memória se todas as bandas forem usadas na computação. Para demonstrar, este exemplo usa muita memória forçando (desnecessariamente) uma coleção de imagens inteira em um bloco:

Ruim: não faça isso.

var bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7'];
var memoryHog = ee.ImageCollection('LANDSAT/LT05/C02/T1').select(bands)
  .toArray()
  .arrayReduce(ee.Reducer.mean(), [0])
  .arrayProject([1])
  .arrayFlatten([bands])
  .reduceRegion({
    reducer: 'mean',
    geometry: ee.Geometry.Point([-122.27, 37.87]).buffer(1000),
    scale: 1,
    bestEffort: true,
  });

// Error: User memory limit exceeded.
print(memoryHog);

import ee
import geemap.core as geemap

bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7']
memory_hog = (
    ee.ImageCollection('LANDSAT/LT05/C02/T1')
    .select(bands)
    .toArray()
    .arrayReduce(ee.Reducer.mean(), [0])
    .arrayProject([1])
    .arrayFlatten([bands])
    .reduceRegion(
        reducer=ee.Reducer.mean(),
        geometry=ee.Geometry.Point([-122.27, 37.87]).buffer(1000),
        scale=1,
        bestEffort=True,
    )
)

# EEException: User memory limit exceeded.
print(memory_hog.getInfo())

Esse código muito ruim demonstra um motivo para não usar matrizes, a menos que seja realmente necessário. Consulte também a seção "Evitar a conversão desnecessária de tipos". Quando essa coleção é convertida em uma matriz gigante, ela precisa ser carregada na memória de uma só vez. Como é uma série temporal longa de imagens, a matriz é grande e não cabe na memória.

Uma solução possível é definir o parâmetro tileScale como um valor maior. Valores mais altos de tileScale resultam em blocos menores por um fator de tileScale^2. Por exemplo, o exemplo a seguir permite que o cálculo seja concluído:

var bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7'];
var smallerHog = ee.ImageCollection('LANDSAT/LT05/C02/T1').select(bands)
  .toArray()
  .arrayReduce(ee.Reducer.mean(), [0])
  .arrayProject([1])
  .arrayFlatten([bands])
  .reduceRegion({
    reducer: 'mean',
    geometry: ee.Geometry.Point([-122.27, 37.87]).buffer(1000),
    scale: 1,
    bestEffort: true,
    tileScale: 16
  });

print(smallerHog);

import ee
import geemap.core as geemap

bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7']
smaller_hog = (
    ee.ImageCollection('LANDSAT/LT05/C02/T1')
    .select(bands)
    .toArray()
    .arrayReduce(ee.Reducer.mean(), [0])
    .arrayProject([1])
    .arrayFlatten([bands])
    .reduceRegion(
        reducer=ee.Reducer.mean(),
        geometry=ee.Geometry.Point([-122.27, 37.87]).buffer(1000),
        scale=1,
        bestEffort=True,
        tileScale=16,
    )
)

print(smaller_hog.getInfo())

No entanto, a solução mais recomendada é não usar matrizes desnecessariamente, para que você não precise mexer com tileScale:

Bom: evite matrizes.

var bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7'];
var okMemory = ee.ImageCollection('LANDSAT/LT05/C02/T1').select(bands)
  .mean()
  .reduceRegion({
    reducer: 'mean',
    geometry: ee.Geometry.Point([-122.27, 37.87]).buffer(1000),
    scale: 1,
    bestEffort: true,
  });

print(okMemory);

import ee
import geemap.core as geemap

bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7']
ok_memory = (
    ee.ImageCollection('LANDSAT/LT05/C02/T1')
    .select(bands)
    .mean()
    .reduceRegion(
        reducer=ee.Reducer.mean(),
        geometry=ee.Geometry.Point([-122.27, 37.87]).buffer(1000),
        scale=1,
        bestEffort=True,
    )
)

print(ok_memory.getInfo())

A menos que seja necessário resolver um erro de memória, não defina tileScale, porque blocos menores também resultam em uma sobrecarga maior de paralelização.

Erros internos

Talvez você encontre um erro parecido com este:

Se esse erro aparecer, clique no link "Report error" (Informar erro) que aparece no console do editor de código JavaScript. Você também pode enviar feedback pelo botão Help. Esse erro pode ser resultado de erros lógicos no script que só se tornam óbvios no momento da execução ou um problema com o funcionamento interno do Earth Engine. Em qualquer caso, o erro não é informativo e precisa ser informado para que possa ser corrigido.

Erros internos incluem um ID request, como este:

Essas strings funcionam como identificadores exclusivos para ajudar a equipe do Earth Engine a identificar problemas específicos. Inclua essa string nos relatórios de bugs.

Métodos de depuração

Você programou sua análise, a executou e recebeu um erro. E agora? Esta seção descreve técnicas gerais de depuração para isolar e corrigir o problema.

Inspecionar variáveis e camadas do mapa

Digamos que você tenha uma análise muito complexa que produz um erro. Se não for óbvio onde o erro se origina, uma boa estratégia inicial é imprimir ou visualizar objetos intermediários e inspecioná-los para garantir que a estrutura do objeto seja consistente com a lógica do script. Especificamente, é possível inspecionar os valores de pixel das camadas adicionadas ao mapa com as ferramentas do editor de código ou do inspetor do geemap. Se você imprimir algo, abra as propriedades com os zippies (▶). Confira alguns itens:

• Nomes de bandas. Os nomes das faixas de imagem correspondem ao seu código?
• Valores de pixel. Seus dados têm o intervalo certo? Ele está mascarado adequadamente?
• Nulo. Há algum valor nulo que não deveria existir?
• Tamanhos. O tamanho é zero quando não deveria ser?

aside()

Pode ser trabalhoso colocar cada etapa intermediária de uma análise em uma variável para que ela possa ser impressa e inspecionada. Para imprimir valores intermediários de uma longa cadeia de chamadas de função, use o método aside(). Exemplo:

var image = ee.Image(ee.ImageCollection('COPERNICUS/S2')
    .filterBounds(ee.Geometry.Point([-12.29, 168.83]))
    .aside(print)
    .filterDate('2011-01-01', '2016-12-31')
    .first());

import ee
import geemap.core as geemap

image = ee.Image(
    ee.ImageCollection('COPERNICUS/S2_HARMONIZED')
    .filterBounds(ee.Geometry.Point([-12.29, 168.83]))
    .aside(display)
    .filterDate('2011-01-01', '2016-12-31')
    .first()
)

Lembre-se de que aside(print) (editor de código JavaScript) e aside(display) (geemap do Python) estão chamando funções do lado do cliente e ainda falham em funções mapeadas. Também é possível usar o aside com funções definidas pelo usuário. Exemplo:

var composite = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
    .filterBounds(ee.Geometry.Point([106.91, 47.91]))
    .map(function(image) {
      return image.addBands(image.normalizedDifference(['B5', 'B4']));
    })
    .aside(Map.addLayer, {bands: ['B4', 'B3', 'B2'], max: 0.3}, 'collection')
    .qualityMosaic('nd');

Map.setCenter(106.91, 47.91, 11);
Map.addLayer(composite, {bands: ['B4', 'B3', 'B2'], max: 0.3}, 'composite');

import ee
import geemap.core as geemap

m = geemap.Map()
m.set_center(106.91, 47.91, 11)

composite = (
    ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
    .filterBounds(ee.Geometry.Point([106.91, 47.91]))
    .map(lambda image: image.addBands(image.normalizedDifference(['B5', 'B4'])))
    .aside(m.add_layer, {'bands': ['B4', 'B3', 'B2'], 'max': 0.3}, 'collection')
    .qualityMosaic('nd')
)

m.add_layer(composite, {'bands': ['B4', 'B3', 'B2'], 'max': 0.3}, 'composite')
m

Como executar uma função em first()

A impressão e a visualização são úteis para depuração quando disponíveis, mas, ao depurar uma função mapeada em uma coleção, não é possível imprimir na função, conforme descrito na seção de funções mapeadas. Nesse caso, é útil isolar elementos problemáticos na coleção e testar a função mapeada em um elemento individual. Ao testar a função sem mapeá-la, use instruções de impressão para entender o problema. Veja o exemplo a seguir.

Erro: este código não funciona.

var image = ee.Image(
    'COPERNICUS/S2_HARMONIZED/20150821T111616_20160314T094808_T30UWU');

var someFeatures = ee.FeatureCollection([
  ee.Feature(ee.Geometry.Point([-2.02, 48.43])),
  ee.Feature(ee.Geometry.Point([-2.80, 48.37])),
  ee.Feature(ee.Geometry.Point([-1.22, 48.29])),
  ee.Feature(ee.Geometry.Point([-1.73, 48.65])),
]);

var problem = someFeatures.map(function(feature) {

  var dictionary = image.reduceRegion({
    reducer: 'first',
    geometry: feature.geometry(),
    scale: 10,
  });

  return feature.set({
    result: ee.Number(dictionary.get('B5'))
                .divide(dictionary.get('B4'))
  });
});

// Error in map(ID=2):
//  Number.divide: Parameter 'left' is required.
print(problem);

import ee
import geemap.core as geemap

image = ee.Image(
    'COPERNICUS/S2_HARMONIZED/20150821T111616_20160314T094808_T30UWU'
)

some_features = ee.FeatureCollection([
    ee.Feature(ee.Geometry.Point([-2.02, 48.43])),
    ee.Feature(ee.Geometry.Point([-2.80, 48.37])),
    ee.Feature(ee.Geometry.Point([-1.22, 48.29])),
    ee.Feature(ee.Geometry.Point([-1.73, 48.65])),
])


# Define a function to be mapped over the collection.
def function_to_map(feature):
  dictionary = image.reduceRegion(
      reducer=ee.Reducer.first(), geometry=feature.geometry(), scale=10
  )

  return feature.set(
      {'result': ee.Number(dictionary.get('B5')).divide(dictionary.get('B4'))}
  )


problem = some_features.map(function_to_map)

# EEException: Error in map(ID=2):
#  Number.divide: Parameter 'left' is required.
print(problem.getInfo())

Para depurar isso, é instrutivo examinar o erro. Felizmente, esse erro útil informa que há um problema com o recurso ID=2. Para investigar mais, é útil refatorar um pouco o código. Especificamente, não é possível ter instruções de impressão na função quando ela é mapeada em uma coleção, conforme descrito nesta seção. O objetivo da depuração é isolar o recurso problemático e executar a função com algumas instruções de impressão. Com a mesma imagem e recursos usados anteriormente:

// Define a function to be mapped over the collection.
var functionToMap = function(feature) {

  var dictionary = image.reduceRegion({
    reducer: 'first',
    geometry: feature.geometry(),
    scale: 10,
  });

  // Debug:
  print(dictionary);

  return feature.set({
    result: ee.Number(dictionary.get('B5'))
                .divide(dictionary.get('B4'))
  });
};

// Isolate the feature that's creating problems.
var badFeature = ee.Feature(someFeatures
    .filter(ee.Filter.eq('system:index', '2'))
    .first());

// Test the function with print statements added.
functionToMap(badFeature);

// Inspect the bad feature in relation to the image.
Map.centerObject(badFeature, 11);
Map.addLayer(badFeature, {}, 'bad feature');
Map.addLayer(image, {bands: ['B4', 'B3', 'B2'], max: 3000}, 'image');

import ee
import geemap.core as geemap

# Define a function to be mapped over the collection.
def function_to_map(feature):
  dictionary = image.reduceRegion(
      reducer=ee.Reducer.first(), geometry=feature.geometry(), scale=10
  )

  # Debug:
  display(dictionary)

  return feature.set(
      {'result': ee.Number(dictionary.get('B5')).divide(dictionary.get('B4'))}
  )


# Isolate the feature that's creating problems.
bad_feature = ee.Feature(
    some_features.filter(ee.Filter.eq('system:index', '2')).first()
)

# Test the function with print statements added.
function_to_map(bad_feature)

# Inspect the bad feature in relation to the image.
m = geemap.Map()
m.center_object(bad_feature, 11)
m.add_layer(bad_feature, {}, 'bad feature')
m.add_layer(image, {'bands': ['B4', 'B3', 'B2'], 'max': 3000}, 'image')
m

Agora, como a função é executada apenas em um recurso, você pode colocar uma chamada de impressão ("display" para o geemap do Python) dentro dela. Inspecione o objeto impresso para descobrir (ah ha!) que o objeto retornado por reduceRegion() tem valores nulos para cada faixa. Isso explica por que a divisão está falhando: porque não é possível dividir nulos por nulos. Por que ele é nulo? Para investigar, adicione a imagem de entrada e o elemento incorreto ao mapa e centralize o elemento incorreto. Ao fazer isso, você descobre que o problema é devido ao ponto estar fora dos limites da imagem. Com base nessa descoberta, o código de depuração é:

var functionToMap = function(feature) {
  var dictionary = image.reduceRegion({
    reducer: 'first',
    geometry: feature.geometry(),
    scale: 10,
  });
  return feature.set({
    result: ee.Number(dictionary.get('B5'))
                .divide(dictionary.get('B4'))
  });
};

var noProblem = someFeatures
    .filterBounds(image.geometry())
    .map(functionToMap);

print(noProblem);

import ee
import geemap.core as geemap

def function_to_map(feature):
  dictionary = image.reduceRegion(
      reducer=ee.Reducer.first(), geometry=feature.geometry(), scale=10
  )

  return feature.set(
      {'result': ee.Number(dictionary.get('B5')).divide(dictionary.get('B4'))}
  )


no_problem = some_features.filterBounds(image.geometry()).map(function_to_map)

display(no_problem)

Profiler

O Profiler fornece informações sobre o tempo de EECU e o uso de memória (por algoritmo e recurso) resultante da computação realizada enquanto ele está ativado. Procure as entradas na parte de cima do perfil para informações sobre as operações que consomem mais recursos. Para scripts de execução longa ou ineficientes, as entradas na parte de cima do Profiler fornecem pistas sobre onde concentrar os esforços para otimizar o script. Observação importante: o próprio perfilador influencia a performance do script. Portanto, execute-o apenas quando necessário.