Cette page a été traduite par l'API Cloud Translation.
Switch to English

Tenseurs et opérations

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é dans un tableau d'une ou plusieurs dimensions. 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, tf.Tensor s aura un float32 dtype. tf.Tensor s peuvent également être créés 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 , 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 d'un Tensor

Vous pouvez également obtenir les valeurs d'un tf.Tensor 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 qui 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 éléments tf.Tensor é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 retournent 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. Le fait de conserver une référence à toutes les variables intermédiaires pour les éliminer 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 retourné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 .