Se usó la API de Cloud Translation para traducir esta página.
Switch to English

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 de dimensión K, mejor pensado como un tensor de índices (K-1) -dimensional 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 la 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 la 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

salida

::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