Assistez au symposium Women in ML le 7 décembre Inscrivez-vous maintenant

Tenseurs et opérations

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

TensorFlow.js est un framework pour définir et 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. tf.Tensor s 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, tf.Tensor s aura un float32 dtype. tf.Tensor s peut également être créé avec les dtypes 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 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. Étant donné qu'il peut souvent y avoir plusieurs formes de la même taille, il est souvent utile de pouvoir remodeler un tf.Tensor en une autre forme de la 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 tenseur

Vous pouvez également obtenir les valeurs d'un tf.Tensor en utilisant les 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 devriez 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 pouvant être effectuées sur des tenseurs.

Exemple : calcul 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 : ajouter des éléments de deux éléments tf.Tensor s :

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

Comme les tenseurs sont immuables, ces opérations ne changent pas leurs valeurs. Au lieu de cela, ops return renvoie 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 sortir de la 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 disposer peut réduire la lisibilité du code. Pour résoudre ce problème, TensorFlow.js fournit une méthode tf.tidy() qui nettoie tous les 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 .