Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

tensorflow :: operaciones :: GatherNd

#include <array_ops.h>

Reúna cortes de params en un tensor con forma especificada por indices .

Resumen

indices es un tensor entero K-dimensional, mejor pensado 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 definen tf.gather en la dimensión del axis de params , en tf.gather_nd , los indices definen tf.gather_nd en las primeras N dimensiones de params , donde N = indices.shape[-1] .

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

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

La última dimensión de los indices corresponde a elementos (si indices.shape[-1] == params.rank ) o rebanadas (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 del límite, se devuelve un error. En GPU, si se encuentra un índice fuera del límite, 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']

Corte la indexación en una matriz:

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

Indexación en un tensor de 3:

    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 de cortes por lotes 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:

    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']]

Consulte también tf.gather y tf.batch_gather .

Argumentos:

  • alcance: un objeto de alcance
  • params: el tensor del que se obtienen los valores.
  • índices: tensor de índice.

Devoluciones:

  • Output : valores de los params recopilados de í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 publicas

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 publicas

GatherNd

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

nodo

::tensorflow::Node * node() const 

operador :: tensorflow :: Entrada

 operator::tensorflow::Input() const 

operador :: tensorflow :: Salida

 operator::tensorflow::Output() const