Previsões de imagem

O Earth Engine fornece ee.Model como um conector para modelos hospedados na Vertex AI. Esse conector envia dados de imagem ou tabela como solicitações de previsão on-line para um modelo treinado implantado em um endpoint da Vertex AI. As saídas do modelo são retornadas como imagens ou tabelas do Earth Engine.

ee.Model.predictImage

Use model.predictImage() para fazer previsões em um ee.Image usando um modelo hospedado. O ee.Image é usado para criar blocos (patch de imagem) de bandas que são enviados ao modelo hospedado. O tipo de retorno de predictImage() é um ee.Image que pode ser adicionado ao mapa, exportado ou usado em outros cálculos.

Opções de entrada

Ao realizar inferências usando um ee.Image, há vários parâmetros usados no conector ee.Model. Esses controles são para as bandas e propriedades de entrada, o agrupamento de patches de imagem de entrada, o tamanho do patch de imagem de saída e as bandas de imagem de saída.

Bandas e propriedades

Para especificar as bandas e propriedades de entrada, use os seguintes parâmetros:

inputProperties

inputProperties é uma lista de nomes de propriedades a serem encaminhados para cada instância de previsão. As propriedades numéricas, de string e booleanas são compatíveis.

inputTypeOverride

inputTypeOverride é um dicionário de nomes de propriedades e/ou bandas com informações específicas de tipo e dimensão. Isso pode ser necessário porque muitos algoritmos do Earth Engine criam saídas com tipos dinâmicos que não podem ser inferidos até o momento da execução.

Por exemplo, se você estiver calculando "slope" mapeando a função ee.Terrain.slope em uma coleção, será necessário especificar o tipo de saída de "slope" nas entradas de inferência, desta forma:

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

DICA: se você encontrar a mensagem de erro de que uma banda ou propriedade "não pode ser convertida em um tensor", uma solução possível é usar uma substituição de tipo para forçar a entrada para um determinado tipo.

inputShapes

inputShapes é um dicionário de nomes de bandas e formato de pixel de matriz. Para enviar ao modelo pixels com valores de matriz com comprimentos maiores que 1, defina o argumento inputShapes. O argumento é semelhante a inputTypeOverride, mas é específico para formas de banda de entrada para previsões de imagem. Por exemplo, para codificar três bandas, (1) "ndvi_series" como uma série temporal 1D com 12 valores, (2) "temp" como um escalar e (3) "patch" como uma matriz de pixels 2D, use o seguinte:

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

outputBands

outputBands é um dicionário de nomes de bandas de saída para um objeto que contém o ee.PixelType e as dimensões da banda. Aqui, as dimensões precisam ser as mesmas do comprimento da matriz de dimensões do Tensor. Em outras palavras, dados escalares com formato () precisam ter dimensão 0, dados 1D com formato (N) precisam ter dimensões 1, dados 2D com formato (N, M) precisam ter dimensões 2. Por exemplo, uma banda de saída chamada "B1" com pixels de valor de matriz com forma é especificada com o seguinte:

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

Tamanhos de blocos

Você controla como a imagem é dividida em blocos usando os seguintes parâmetros:

  • inputTileSize
  • inputOverlapSize
  • outputTileSize

Tamanhos dos blocos de entrada

Para definir os tamanhos dos blocos de entrada, use inputTileSize e inputOverlapSize. Defina esses parâmetros fornecendo um par de largura e altura de bloco em pixels (por exemplo, [32, 32]). O tamanho total do patch é determinado pela adição das alturas e larguras de inputTileSize e outputTileSize.

Por exemplo, um modelo totalmente convolucional pode esperar entradas com formato (256 x 256 x canais). Se estivermos preocupados com os efeitos de borda entre os resultados da inferência, podemos descartar inputOverlapSize[0] pixels da esquerda e da direita e inputOverlapSize[1] da parte de cima e de baixo de cada resultado da inferência. Isso resultará em mais chamadas de previsão para cobrir totalmente a área de previsão.

Por exemplo, se o modelo espera (256 x 256 x 3) e queremos descartar os 32 pixels de borda, especificamos o seguinte:

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

OBSERVAÇÃO: o inputOverlapSize é uma sobreposição total de x e y. Se você pretende ter um buffer de N pixels ao redor de toda a imagem, a sobreposição será [2N, 2N]

Tamanho do bloco de saída

Para definir o tamanho do bloco de saída, defina o argumento outputTileSize. Se outputTileSize não estiver definido, o tamanho padrão do bloco será idêntico a inputTileSize.

Em alguns modelos, o tamanho da saída pode ser diferente do tamanho da entrada. Por exemplo, um modelo de classificação pode aceitar entradas com formato (256, 256, canais), mas retornar tensores com o formato (1, 1, 1). Nesse caso, o outputTileSize precisa ser definido como [1, 1]. Isso é bastante comum com modelos que retornam a saída de probabilidade (em uma resolução reduzida) de alguma característica do bloco.

Projeção

Quase todos os modelos convolucionais esperam uma entrada de projeção fixa. Isso ocorre porque a maioria dos modelos convolucionais é treinada em uma escala fixa. Nesse caso, defina o parâmetro fixInputProj como true na chamada para ee.Model.fromVertexAi() e especifique a projeção dos dados no parâmetro proj.

A projeção da imagem de entrada e a projeção fixa do modelo vão afetar os valores de saída. Consulte o guia de reprojeção do EE.