flujo tensor:: operaciones:: Reunir

#include <array_ops.h>

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

Resumen

indices es un tensor entero de K-dimensional, mejor considerado 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 define sectores en la primera dimensión de params , en tf.gather_nd , indices define sectores 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 sectores (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 límite, se devuelve un error. En GPU, si se encuentra un índice fuera de 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']

Divida 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 sectores 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 cual recolectar valores.
  • índices: tensor de índice.

Devoluciones:

  • Output : valores de 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 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

Reunir 

 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