ScatterNd

Espalhe `updates` em um novo tensor de acordo com `indices`.

Cria um novo tensor aplicando `atualizações` esparsas a valores individuais ou fatias dentro de um tensor (inicialmente zero para numérico, vazio para string) da `forma` fornecida de acordo com os índices. Este operador é o inverso do operador `tf.gather_nd` que extrai valores ou fatias de um determinado tensor.

Essa operação é semelhante a tensor_scatter_add, exceto que o tensor é inicializado com zero. Chamar `tf.scatter_nd(indices, values, shape)` é idêntico a `tensor_scatter_add(tf.zeros(shape, values.dtype), indices, values)`

Se `índices` contiverem duplicatas, suas atualizações serão acumuladas (somadas).

AVISO : A ordem na qual as atualizações são aplicadas não é determinística, então a saída não será determinística se `índices` contiverem duplicatas -- devido a alguns problemas de aproximação numérica, números somados em ordem diferente podem produzir resultados diferentes.

`indices` é um tensor inteiro contendo índices em um novo tensor de forma `shape`. A última dimensão de `índices` pode ser no máximo a classificação de `forma`:

índices.forma[-1] <= forma.classificação

A última dimensão de `indices` corresponde a índices em elementos (se `indices.shape[-1] = shape.rank`) ou fatias (se `indices.shape[-1] < shape.rank`) ao longo da dimensão `indices .shape[-1]` de `shape`. `updates` é um tensor com forma

índices.forma[:-1] + forma[índices.forma[-1]:]

A forma mais simples de dispersão é inserir elementos individuais em um tensor por índice. Por exemplo, digamos que queremos inserir 4 elementos dispersos em um tensor de rank 1 com 8 elementos.

Em Python, esta operação de dispersão ficaria assim:

indices = tf.constant([[4], [3], [1], [7]])
     updates = tf.constant([9, 10, 11, 12])
     shape = tf.constant([8])
     scatter = tf.scatter_nd(indices, updates, shape)
     print(scatter)
 

[0, 11, 0, 10, 9, 0, 0, 12]

Também podemos inserir fatias inteiras de um tensor de classificação mais alta de uma só vez. Por exemplo, se quisermos inserir duas fatias na primeira dimensão de um tensor de rank 3 com duas matrizes de novos valores.

Em Python, esta operação de dispersão ficaria assim:

indices = tf.constant([[0], [2]])
     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
                             [7, 7, 7, 7], [8, 8, 8, 8]],
                            [[5, 5, 5, 5], [6, 6, 6, 6],
                             [7, 7, 7, 7], [8, 8, 8, 8]]])
     shape = tf.constant([4, 4, 4])
     scatter = tf.scatter_nd(indices, updates, shape)
     print(scatter)
 

[[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], [[0, 0, 0 , 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[5, 5, 5, 5], [6, 6] , 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], [[0, 0, 0, 0], [0, 0, 0, 0], [0 , 0, 0, 0], [0, 0, 0, 0]]]

Observe que na CPU, se um índice fora do limite for encontrado, um erro será retornado. Na GPU, se um índice fora do limite for encontrado, o índice será ignorado.