Tenseurs et opérations

TensorFlow.js est un framework permettant de définir et d'exécuter des calculs à l'aide de tenseurs en JavaScript. Un tenseur est une généralisation de vecteurs et de matrices à des dimensions supérieures.

Tenseurs

L'unité centrale de données dans TensorFlow.js est le tf.Tensor : un ensemble de valeurs formées dans un tableau d'une ou plusieurs dimensions. Les tf.Tensor sont très similaires aux tableaux multidimensionnels.

Un tf.Tensor contient également les propriétés suivantes :

  • rank : définit le nombre de dimensions que contient le tenseur
  • shape : qui définit la taille de chaque dimension des données
  • dtype : qui définit le type de données du tenseur.

Un tf.Tensor peut être créé à partir d'un tableau avec la méthode tf.tensor() :

// 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();

Par défaut, les tf.Tensor auront un type float32 dtype. Les tf.Tensor peuvent également être créés avec les types bool, int32, complex64 et string :

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 fournit également un ensemble de méthodes pratiques pour créer des tenseurs aléatoires, des tenseurs remplis d'une valeur particulière, des tenseurs à partir de HTMLImageElement s et bien d'autres que vous pouvez trouver ici .

Changer la forme d'un tenseur

Le nombre d'éléments dans un tf.Tensor est le produit des tailles dans sa forme. Comme il peut souvent y avoir plusieurs formes de même taille, il est souvent utile de pouvoir remodeler un tf.Tensor en une autre forme de même taille. Ceci peut être réalisé avec la méthode reshape() :

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();

Obtenir des valeurs à partir d'un Tensor

Vous pouvez également obtenir les valeurs d'un tf.Tensor en utilisant les méthodes Tensor.array() ou Tensor.data() :

 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));

Nous fournissons également des versions synchrones de ces méthodes qui sont plus simples à utiliser, mais entraîneront des problèmes de performances dans votre application. Vous devez toujours préférer les méthodes asynchrones dans les applications de production.

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());

Opérations

Alors que les tenseurs vous permettent de stocker des données, les opérations (ops) vous permettent de manipuler ces données. TensorFlow.js fournit également une grande variété d'opérations adaptées à l'algèbre linéaire et à l'apprentissage automatique qui peuvent être effectuées sur des tenseurs.

Exemple : calcul de x 2 de tous les éléments d'un tf.Tensor :

const x = tf.tensor([1, 2, 3, 4]);
const y = x.square();  // equivalent to tf.square(x)
y.print();

Exemple : ajout d'éléments de deux tf.Tensor élément par élément :

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();

Parce que les tenseurs sont immuables, ces opérations ne changent pas leurs valeurs. Au lieu de cela, les opérations return renvoient toujours de nouveaux tf.Tensor s.

Vous pouvez trouver une liste des opérations prises en charge par TensorFlow.js ici .

Mémoire

Lors de l'utilisation du backend WebGL, la mémoire tf.Tensor doit être gérée explicitement (il ne suffit pas de laisser un tf.Tensor hors de portée pour que sa mémoire soit libérée).

Pour détruire la mémoire d'un tf.Tensor, vous pouvez utiliser la méthode dispose() ou tf.dispose() :

const a = tf.tensor([[1, 2], [3, 4]]);
a.dispose(); // Equivalent to tf.dispose(a)

Il est très courant d’enchaîner plusieurs opérations dans une application. Conserver une référence à toutes les variables intermédiaires pour les supprimer peut réduire la lisibilité du code. Pour résoudre ce problème, TensorFlow.js fournit une méthode tf.tidy() qui nettoie tous tf.Tensor qui ne sont pas renvoyés par une fonction après son exécution, de la même manière que les variables locales sont nettoyées lorsqu'une fonction est exécutée :

const a = tf.tensor([[1, 2], [3, 4]]);
const y = tf.tidy(() => {
  const result = a.square().log().neg();
  return result;
});

Dans cet exemple, le résultat de square() et log() sera automatiquement supprimé. Le résultat de neg() ne sera pas supprimé car il s’agit de la valeur de retour de tf.tidy().

Vous pouvez également obtenir le nombre de Tensors suivis par TensorFlow.js :

console.log(tf.memory());

L'objet imprimé par tf.memory() contiendra des informations sur la quantité de mémoire actuellement allouée. Vous pouvez trouver plus d'informations ici .