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.

Remarque : Nous utiliserons le terme « dimension » de manière interchangeable avec le terme. Parfois, dans l'apprentissage automatique, la « dimensionnalité » d'un tenseur peut également faire référence à la taille d'une dimension particulière (par exemple, une matrice de forme [10, 5] est un tenseur de rang 2, ou un tenseur à 2 dimensions. La dimensionnalité du la première dimension est 10. Cela peut prêter à confusion, mais nous mettons cette note ici car vous rencontrerez probablement ces doubles usages du terme).

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

Remarque : la plupart des opérations renvoient tf.Tensor s, mais le résultat n'est peut-être pas encore prêt. Cela signifie que le tf.Tensor que vous obtenez est en fait un handle pour le calcul. Lorsque vous appelez Tensor.data() ou Tensor.array() , ces méthodes renvoient des promesses qui se résolvent avec des valeurs uniquement lorsque le calcul est terminé. Lors de l'exécution dans un contexte d'interface utilisateur (tel qu'une application de navigateur), vous devez toujours préférer les versions asynchrones de ces méthodes plutôt que leurs homologues synchrones pour éviter de bloquer le thread de l'interface utilisateur jusqu'à la fin du calcul.

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 .