tensorflow:: ops:: GatherNd

#include <array_ops.h>

Reúna las porciones de params en un Tensor con la forma especificada por indices .

Resumen

indices es un tensor entero K-dimensional, que se puede considerar como un tensor (K-1)-dimensional de índices en params , donde cada elemento define una porción de params :

output[\\(i_0, ..., i_{K-2}\\)] = params[indices[\\(i_0, ..., i_{K-2}\\)]]

Mientras que en tf.gather indices define cortes en la primera dimensión de params , en tf.gather_nd , indices define cortes en las primeras N dimensiones de params , donde N = indices.shape[-1] .

La última dimensión de indices puede ser como máximo el rango de params :

indices.shape[-1] <= params.rank

La última dimensión de indices corresponde a elementos (si indices.shape[-1] == params.rank ) o segmentos (si indices.shape[-1] < params.rank ) a lo largo de la dimensión indices.shape[-1] de params . El tensor de salida tiene forma

indices.shape[:-1] + params.shape[indices.shape[-1]:]

Tenga en cuenta que, en la CPU, si se encuentra un índice fuera de rango, se devuelve un error. En la GPU, si se encuentra un índice fuera de rango, se almacena un 0 en el valor de salida correspondiente.

Algunos ejemplos a continuación.

Indexación simple en una matriz: 

    indices = [[0, 0], [1, 1]]
    params = [['a', 'b'], ['c', 'd']]
    output = ['a', 'd']

Indexación de segmentos en una matriz: 

    indices = [[1], [0]]
    params = [['a', 'b'], ['c', 'd']]
    output = [['c', 'd'], ['a', 'b']]

Indexación en un tensor de 3 dimensiones: 

    indices = [[1]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [[['a1', 'b1'], ['c1', 'd1']]]

    indices = [[0, 1], [1, 0]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [['c0', 'd0'], ['a1', 'b1']]

    indices = [[0, 0, 1], [1, 0, 1]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = ['b0', 'b1']

Indexación por lotes en una matriz: 

    indices = [[[0, 0]], [[0, 1]]]
    params = [['a', 'b'], ['c', 'd']]
    output = [['a'], ['b']]

Indexación por lotes de segmentos en una matriz: 

    indices = [[[1]], [[0]]]
    params = [['a', 'b'], ['c', 'd']]
    output = [[['c', 'd']], [['a', 'b']]]

Indexación por lotes en un tensor de 3 elementos: 

    indices = [[[1]], [[0]]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [[[['a1', 'b1'], ['c1', 'd1']]],
              [[['a0', 'b0'], ['c0', 'd0']]]]

    indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [[['c0', 'd0'], ['a1', 'b1']],
              [['a0', 'b0'], ['c1', 'd1']]]

    indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
    params = [[['a0', 'b0'], ['c0', 'd0']],
              [['a1', 'b1'], ['c1', 'd1']]]
    output = [['b0', 'b1'], ['d0', 'c1']]

Véase también tf.gather y tf.batch_gather .

Argumentos:

  • ámbito: Un objeto de ámbito
  • params: El tensor del que se obtendrán los valores.
  • índices: tensor de índices.

Devoluciones:

  • Output : Valores de params recopilados de los índices dados por indices , con forma indices.shape[:-1] + params.shape[indices.shape[-1]:] .

Constructores y destructores

GatherNd (const :: tensorflow::Scope & scope, :: tensorflow::Input params, :: tensorflow::Input indices)

Atributos públicos

operation
output

Funciones públicas

node () const
::tensorflow::Node *
operator::tensorflow::Input () const
operator::tensorflow::Output () const

Atributos públicos

operación 

Operation operation

producción 

::tensorflow::Output output

Funciones públicas

Reúnanse y 

 GatherNd(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input params,
  ::tensorflow::Input indices
)

nodo 

::tensorflow::Node * node() const

operador::tensorflow::Input 

 operator::tensorflow::Input() const

operador::tensorflow::Salida 

 operator::tensorflow::Output() const