Questa pagina è stata tradotta dall'API Cloud Translation.

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 ² 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.

Nota: la maggior parte delle operazioni di ritorno tf.Tensor s, ma il risultato potrebbe non essere effettivamente ancora pronto. Questo significa che il tf.Tensor che si ottiene è in realtà una maniglia per il calcolo. Quando si chiama Tensor.data() o Tensor.array() , questi metodi restituiscono promesse che si risolvono con i valori solo quando il calcolo è finito. Durante l'esecuzione in un contesto dell'interfaccia utente (come un'app browser), dovresti sempre preferire le versioni asincrone di questi metodi anziché le loro controparti sincrone per evitare di bloccare il thread dell'interfaccia utente fino al completamento del calcolo.

È 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 .