TensorFlow.js è un framework per definire ed eseguire calcoli utilizzando tensori in JavaScript. Un tensore è una generalizzazione di vettori e matrici di dimensioni superiori.
tensori
L'unità centrale di dati in TensorFlow.js rappresenta l' tf.Tensor
: un insieme di valori di forma in una matrice di una o più dimensioni. tf.Tensor
s sono molto simili agli array multidimensionali.
Un tf.Tensor
contiene anche le seguenti proprietà:
-
rank
: definisce quante dimensioni tensore contiene -
shape
: che definisce la dimensione di ogni dimensione dei dati -
dtype
: che definisce il tipo di dati del tensore.
Un tf.Tensor
può essere creato da una matrice con il tf.tensor()
Metodo:
// Create a rank-2 tensor (matrix) matrix tensor from a multidimensional array.
const a = tf.tensor([[1, 2], [3, 4]]);
console.log('shape:', a.shape);
a.print();
// Or you can create a tensor from a flat array and specify a shape.
const shape = [2, 2];
const b = tf.tensor([1, 2, 3, 4], shape);
console.log('shape:', b.shape);
b.print();
Per impostazione predefinita, tf.Tensor
s avrà un float32
dtype.
tf.Tensor
s possono anche essere creati con bool, Int32, complex64, e dtypes stringa:
const a = tf.tensor([[1, 2], [3, 4]], [2, 2], 'int32');
console.log('shape:', a.shape);
console.log('dtype', a.dtype);
a.print();
TensorFlow.js fornisce anche una serie di metodi di convenienza per la creazione di tensori casuali, tensori riempito con un particolare valore, tensori da HTMLImageElement
s, e molti altri che potete trovare qui .
Modificare la forma di un tensore
Il numero di elementi in una tf.Tensor
è il prodotto delle dimensioni nella sua forma. Poiché spesso volte ci possono essere molteplici forme con le stesse dimensioni, è spesso utile essere in grado di rimodellare un tf.Tensor
ad un'altra forma con la stessa dimensione. Ciò può essere ottenuto con il reshape()
Metodo:
const a = tf.tensor([[1, 2], [3, 4]]);
console.log('a shape:', a.shape);
a.print();
const b = a.reshape([4, 1]);
console.log('b shape:', b.shape);
b.print();
Ottenere valori da un tensore
È inoltre possibile ottenere i valori da un tf.Tensor
utilizzando il Tensor.array()
o Tensor.data()
metodi:
const a = tf.tensor([[1, 2], [3, 4]]);
// Returns the multi dimensional array of values.
a.array().then(array => console.log(array));
// Returns the flattened data that backs the tensor.
a.data().then(data => console.log(data));
Forniamo anche versioni sincrone di questi metodi che sono più semplici da usare, ma causeranno problemi di prestazioni nella tua applicazione. Dovresti sempre preferire i metodi asincroni nelle applicazioni di produzione.
const a = tf.tensor([[1, 2], [3, 4]]);
// Returns the multi dimensional array of values.
console.log(a.arraySync());
// Returns the flattened data that backs the tensor.
console.log(a.dataSync());
operazioni
Mentre i tensori consentono di memorizzare dati, le operazioni (ops) consentono di manipolare tali dati. TensorFlow.js fornisce anche un'ampia varietà di operazioni adatte per l'algebra lineare e l'apprendimento automatico che possono essere eseguite sui tensori.
Esempio: calcolo x 2 di tutti gli elementi in un tf.Tensor
:
const x = tf.tensor([1, 2, 3, 4]);
const y = x.square(); // equivalent to tf.square(x)
y.print();
Esempio: aggiunta di elementi di due tf.Tensor
s elemento saggio:
const a = tf.tensor([1, 2, 3, 4]);
const b = tf.tensor([10, 20, 30, 40]);
const y = a.add(b); // equivalent to tf.add(a, b)
y.print();
Poiché i tensori sono immutabili, queste operazioni non cambiano i loro valori. Invece, ops restituiscono sempre ritornano nuovi tf.Tensor
s.
È possibile trovare un elenco di supporti le operazioni TensorFlow.js qui .
Memoria
Quando si utilizza il backend WebGL, tf.Tensor
memoria deve essere gestito in modo esplicito (non è sufficiente lasciare che un tf.Tensor
andare fuori portata per la sua memoria per essere rilasciato).
Per distruggere la memoria di un tf.Tensor, è possibile utilizzare la dispose()
metodo o tf.dispose()
:
const a = tf.tensor([[1, 2], [3, 4]]);
a.dispose(); // Equivalent to tf.dispose(a)
È molto comune concatenare più operazioni insieme in un'applicazione. Tenere un riferimento a tutte le variabili intermedie per eliminarle può ridurre la leggibilità del codice. Per risolvere questo problema, TensorFlow.js fornisce un tf.tidy()
metodo che pulisce tutto tf.Tensor
s non restituiti da una funzione dopo l'esecuzione di esso, simile al modo in cui le variabili locali vengono eliminati quando viene eseguita una funzione:
const a = tf.tensor([[1, 2], [3, 4]]);
const y = tf.tidy(() => {
const result = a.square().log().neg();
return result;
});
In questo esempio, il risultato del square()
e log()
sarà automaticamente disposti. Il risultato di neg()
non sarà disposto in quanto è il valore di ritorno del tf.tidy ().
Puoi anche ottenere il numero di tensori tracciati da TensorFlow.js:
console.log(tf.memory());
L'oggetto stampato da tf.memory()
conterrà informazioni sulla quantità di memoria attualmente allocata. E 'possibile trovare maggiori informazioni qui .