GatherNd

public final class GatherNd

Raccogli sezioni da "params" in un tensore con la forma specificata da "indici".

`indices` è un tensore intero K-dimensionale, meglio pensato come un tensore (K-1) -dimensionale di indici in` params`, dove ogni elemento definisce una fetta di `params`:

output [\ \(i_0, ..., i_{K-2}\\)] = params [indici [\ \(i_0, ..., i_{K-2}\\)]]

Mentre in `tf.gather`` indices` definisce le sezioni nella dimensione `axis` di` params`, in `tf.gather_nd`,` indices` definisce le sezioni nelle prime `N` dimensioni di` params`, dove `N = indices.shape [-1] `.

L'ultima dimensione di "indici" può essere al massimo il rango di "params":

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

L'ultima dimensione di `indices` corrisponde agli elementi (se` indices.shape [-1] == params.rank`) o sezioni (se `indices.shape [-1] <params.rank`) lungo gli indici di dimensione`. forma [-1] `di` params`. Il tensore di uscita ha forma

indices.shape [: - 1] + params.shape [indices.shape [-1]:]

Notare che sulla CPU, se viene trovato un indice fuori limite, viene restituito un errore. Sulla GPU, se viene trovato un indice fuori limite, viene memorizzato uno 0 nel valore di output corrispondente.

Alcuni esempi di seguito.

Indicizzazione semplice in una matrice:

indices = [[0, 0], [1, 1]]
     params = [['a', 'b'], ['c', 'd']]
     output = ['a', 'd']
 
Divisione dell'indicizzazione in una matrice:
indices = [[1], [0]]
     params = [['a', 'b'], ['c', 'd']]
     output = [['c', 'd'], ['a', 'b']]
 
Indicizzazione in un 3-tensore:
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']
 
Indicizzazione in batch in una matrice:
indices = [[[0, 0]], [[0, 1]]]
     params = [['a', 'b'], ['c', 'd']]
     output = [['a'], ['b']]
 
Indicizzazione in batch in una matrice:
indices = [[[1]], [[0]]]
     params = [['a', 'b'], ['c', 'd']]
     output = [[['c', 'd']], [['a', 'b']]]
 
Indicizzazione in batch in una 3-tensor .gather` e `tf.batch_gather`.

Metodi pubblici

Uscita <T>
asOutput ()
Restituisce la maniglia simbolica di un tensore.
static <T, U estende Number> GatherNd <T>
create ( ambito ambito, parametri operando <T>, indici operando <U>)
Metodo Factory per creare una classe che avvolge una nuova operazione GatherNd.
Uscita <T>
output ()
Valori da `params` raccolti da indici forniti da` indices`, con forma `indices.shape [: - 1] + params.shape [indices.shape [-1]:]`.

Metodi ereditati

Metodi pubblici

output pubblico <T> asOutput ()

Restituisce la maniglia simbolica di un tensore.

Gli input per le operazioni TensorFlow sono output di un'altra operazione TensorFlow. Questo metodo viene utilizzato per ottenere un handle simbolico che rappresenta il calcolo dell'input.

public static GatherNd <T> create ( ambito ambito, parametri operando <T>, indici operando <U>)

Metodo Factory per creare una classe che avvolge una nuova operazione GatherNd.

Parametri
scopo ambito attuale
params Il tensore da cui raccogliere i valori.
indici Tensore dell'indice.
ritorna
  • una nuova istanza di GatherNd

output pubblico <T> output ()

Valori da `params` raccolti da indici forniti da` indices`, con forma `indices.shape [: - 1] + params.shape [indices.shape [-1]:]`.