ScatterNd

classe finale pubblica ScatterNd

Distribuisci gli "aggiornamenti" in un nuovo tensore in base agli "indici".

Crea un nuovo tensore applicando "aggiornamenti" sparsi a singoli valori o sezioni all'interno di un tensore (inizialmente zero per numerico, vuoto per stringa) della "forma" data in base agli indici. Questo operatore è l'inverso dell'operatore tf.gather_nd che estrae valori o sezioni da un dato tensore.

Questa operazione è simile a tensor_scatter_add, tranne per il fatto che il tensore è inizializzato con zero. La chiamata tf.scatter_nd(indices, values, shape) è identica a "tensor_scatter_add(tf.zeros(shape,values.dtype), indicis,value)`

Se gli "indici" contengono duplicati, i loro aggiornamenti vengono accumulati (sommati).

ATTENZIONE : l'ordine in cui vengono applicati gli aggiornamenti non è deterministico, quindi l'output sarà non deterministico se "indici" contiene duplicati: a causa di alcuni problemi di approssimazione numerica, i numeri sommati in ordine diverso potrebbero produrre risultati diversi.

"indices" è un tensore intero contenente indici in un nuovo tensore di forma "shape". L'ultima dimensione degli "indici" può essere al massimo il rango di "forma":

indici.forma[-1] <= forma.rango

L'ultima dimensione di "indices" corrisponde agli indici in elementi (se `indices.shape[-1] = shape.rank`) o sezioni (se `indices.shape[-1] < shape.rank`) lungo la dimensione "indices" .forma[-1]` di `forma`. "aggiornamenti" è un tensore con forma

indici.forma[:-1] + forma[indice.forma[-1]:]

La forma più semplice di dispersione consiste nell'inserire singoli elementi in un tensore tramite indice. Ad esempio, supponiamo di voler inserire 4 elementi sparsi in un tensore di rango 1 con 8 elementi.

In Python, questa operazione di dispersione sarebbe simile a questa:

indices = tf.constant([[4], [3], [1], [7]])
     updates = tf.constant([9, 10, 11, 12])
     shape = tf.constant([8])
     scatter = tf.scatter_nd(indices, updates, shape)
     print(scatter)
 
Il tensore risultante sarebbe simile a questo:

[0, 11, 0, 10, 9, 0, 0, 12]

Possiamo anche inserire intere fette di un tensore di rango superiore tutte in una volta. Ad esempio, se volessimo inserire due fette nella prima dimensione di un tensore di rango 3 con due matrici di nuovi valori.

In Python, questa operazione di dispersione sarebbe simile a questa:

indices = tf.constant([[0], [2]])
     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
                             [7, 7, 7, 7], [8, 8, 8, 8]],
                            [[5, 5, 5, 5], [6, 6, 6, 6],
                             [7, 7, 7, 7], [8, 8, 8, 8]]])
     shape = tf.constant([4, 4, 4])
     scatter = tf.scatter_nd(indices, updates, shape)
     print(scatter)
 
Il tensore risultante sarebbe simile a questo:

[[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], [[0, 0, 0 , 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[5, 5, 5, 5], [6, 6 , 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], [[0, 0, 0, 0], [0, 0, 0, 0], [0 , 0, 0, 0], [0, 0, 0, 0]]]

Si noti che sulla CPU, se viene trovato un indice fuori limite, viene restituito un errore. Sulla GPU, se viene trovato un indice fuori limite, l'indice viene ignorato.

Costanti

Corda OP_NAME Il nome di questa operazione, come noto al motore principale di TensorFlow

Metodi pubblici

Uscita <U>
comeuscita ()
Restituisce l'handle simbolico del tensore.
statico <U estende TType , T estende TNumber > ScatterNd <U>
create (ambito dell'ambito , indici dell'operando <T>, aggiornamenti dell'operando <U>, forma dell'operando <T>)
Metodo factory per creare una classe che racchiude una nuova operazione ScatterNd.
Uscita <U>
produzione ()
Un nuovo tensore con la forma data e aggiornamenti applicati in base agli indici.

Metodi ereditati

Costanti

Stringa finale statica pubblica OP_NAME

Il nome di questa operazione, come noto al motore principale di TensorFlow

Valore costante: "ScatterNd"

Metodi pubblici

Uscita pubblica <U> asOutput ()

Restituisce l'handle simbolico del 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 ScatterNd <U> create (ambito dell'ambito , indici dell'operando <T>, aggiornamenti dell'operando <U>, forma dell'operando <T>)

Metodo factory per creare una classe che racchiude una nuova operazione ScatterNd.

Parametri
scopo ambito attuale
indici Tensore dell'indice.
aggiornamenti Aggiornamenti da distribuire nell'output.
forma 1-D. La forma del tensore risultante.
ritorna
  • una nuova istanza di ScatterNd

Uscita pubblica <U> uscita ()

Un nuovo tensore con la forma data e aggiornamenti applicati in base agli indici.