GatherNd

Clase public final GatherNd

Reúna segmentos de "params" en un tensor con la forma especificada por "índices".

`índices` 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`:

de salida [\\(i_0, ..., i_{K-2}\\)] = params [índices [\\(i_0, ..., i_{K-2}\\)]]

Mientras que en `tf.gather`` indices` define sectores en la dimensión `axis` de` params`, en `tf.gather_nd`,` indices` define sectores en las primeras `N` dimensiones de` params`, donde `N = índices.forma [-1] `.

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

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

La última dimensión de `índices` corresponde a elementos (si` indices.shape [-1] == params.rank`) o rebanadas (si `indices.shape [-1] <params.rank`) a lo largo de la dimensión` índices. forma [-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']
 

Slice indexación en una matriz:

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

de indexación en una 3-tensor:

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

lotes rebanada de indexación 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']]
 

Ver también `` tf.gather` y tf.batch_gather`.

Métodos públicos

Salida <T>	asOutput () Devuelve el identificador simbólico de un tensor.
estática <T, U se extiende Número> GatherNd <T>	crear ( Alcance alcance, operando <T> params, operando <U> índices) Método de fábrica para crear una clase que envuelva una nueva operación GatherNd.
Salida <T>	salida () Valores de "params" obtenidos de índices dados por "índices", con forma "indices.shape [: - 1] + params.shape [indices.shape [-1]:]".

Métodos heredados

De la clase org.tensorflow.op.PrimitiveOp

booleano final	es igual a (Object obj)
int final	hashCode ()
Operación	op () Devuelve el que subyace a Operation
cadena final	toString ()

De la clase java.lang.Object

booleano	equals (Object arg0)
Clase final <?>	getClass ()
En t	hashCode ()
vacío final	notificar ()
vacío final	notifyAll ()
Cuerda	toString ()
vacío final	espera (tiempo arg0, arg1 int)
vacío final	espera (arg0 largo)
vacío final	wait ()

Desde la interfaz org.tensorflow.Operand

abstracta de salida <T>

asOutput () Devuelve el identificador simbólico de un tensor.

Métodos públicos

pública de salida <T> asOutput ()

Devuelve el identificador simbólico de un tensor.

Las entradas a las operaciones de TensorFlow son salidas de otra operación de TensorFlow. Este método se utiliza para obtener un identificador simbólico que representa el cálculo de la entrada.

public static GatherNd <T> crear ( Alcance alcance, operando <T> params, operando <U> índices)

Método de fábrica para crear una clase que envuelva una nueva operación GatherNd.

Parámetros

alcance	alcance actual
params	El tensor del que se obtienen los valores.
índices	Tensor de índice.

Devoluciones

• una nueva instancia de GatherNd

pública de salida <T> salida ()

Valores de "params" obtenidos de índices dados por "índices", con forma "indices.shape [: - 1] + params.shape [indices.shape [-1]:]".