Tensori e operazioni

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 .