Reúna sectores de "params" en un tensor con la forma especificada por "índices".
`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`:
producción[\\(i_0, ..., i_{K-2}\\)] = parámetros[índices[\\(i_0, ..., i_{K-2}\\)]]
Mientras que en tf.gather
`indices` define cortes en la dimensión `axis` de `params`, en tf.gather_nd
, `indices` define cortes en las primeras `N` dimensiones de `params`, donde `N = indices.shape [-1]`.
La última dimensión de los "índices" puede ser como máximo el rango de los "parámetros":
índices.forma[-1] <= parámetros.rango
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. forma[-1]` de `params`. El tensor de salida tiene forma.
índices.forma[:-1] + parámetros.forma[índices.forma[-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`. Métodos públicos
Salida <T> | como salida () Devuelve el identificador simbólico de un tensor. |
estático <T, U extiende Número> GatherNd <T> | crear (alcance del alcance , parámetros del operando <T>, índices del operando <U>) Método de fábrica para crear una clase que envuelve una nueva operación GatherNd. |
Salida <T> | producción () Valores de `params` recopilados de índices dados por `indices`, con forma `indices.shape[:-1] + params.shape[indices.shape[-1]:]`. |
Métodos heredados
Métodos públicos
Salida pública <T> como Salida ()
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> create ( alcance del alcance, parámetros del operando <T>, índices del operando <U>)
Método de fábrica para crear una clase que envuelve una nueva operación GatherNd.
Parámetros
alcance | alcance actual |
---|---|
parámetros | El tensor del que se obtienen valores. |
índices | Tensor de índice. |
Devoluciones
- una nueva instancia de GatherNd
Salida pública <T> salida ()
Valores de `params` recopilados de índices dados por `indices`, con forma `indices.shape[:-1] + params.shape[indices.shape[-1]:]`.