tensorflow :: operaciones :: GatherNd

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

Atributos públicos

Operation operation

::tensorflow::Output output

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

::tensorflow::Node * node() const 

 operator::tensorflow::Input() const 

 operator::tensorflow::Output() const