🤖 Méthodes TensorFlow.js – Les Bases

📚 Méthodes de base JavaScript

Qu’est-ce que TensorFlow.js ?

TensorFlow.js est une bibliothèque JavaScript pour l'entraînement et l'exécution de modèles de machine learning dans le navigateur ou dans Node.js.

Création de tenseurs

tf.tensor()
Créer un tenseur simple à partir d’un tableau.
const t = tf.tensor([1, 2, 3]);
t.print();
tf.tensor2d()
Créer un tenseur 2D (matrice).
const t = tf.tensor2d([[1, 2], [3, 4]]);
t.print();
tf.zeros(), tf.ones(), tf.fill()
Créer un tableau rempli de zéros, de uns ou d'une valeur.
tf.zeros([2, 2]).print();
tf.ones([2, 2]).print();
tf.fill([2, 2], 9).print();

Manipulation de tenseurs

tf.reshape()
Change la forme du tenseur.
const t = tf.tensor([1, 2, 3, 4]);
t.reshape([2, 2]).print();
tf.transpose()
Transpose un tenseur (ligne <-> colonne).
const t = tf.tensor2d([[1, 2], [3, 4]]);
t.transpose().print();
tf.concat(), tf.stack()
Concatène ou empile des tenseurs.

const a = tf.tensor([1, 2]);
const b = tf.tensor([3, 4]);
tf.concat([a, b]).print();
tf.stack([a, b]).print();

Opérations mathématiques de base

tf.add(a, b)
Additionne deux tenseurs élément par élément.
const a = tf.tensor([1, 2]);
const b = tf.tensor([3, 4]);
tf.add(a, b).print(); // [4, 6]
tf.sub(a, b)
Soustrait le deuxième tenseur du premier.
const a = tf.tensor([5, 6]);
const b = tf.tensor([2, 4]);
tf.sub(a, b).print(); // [3, 2]
tf.mul(a, b)
Multiplie deux tenseurs élément par élément.
const a = tf.tensor([2, 3]);
const b = tf.tensor([4, 5]);
tf.mul(a, b).print(); // [8, 15]
tf.div(a, b)
Divise un tenseur par un autre.
const a = tf.tensor([10, 20]);
const b = tf.tensor([2, 4]);
tf.div(a, b).print(); // [5, 5]
tf.pow(a, exp)
Élève chaque élément à une puissance.
const a = tf.tensor([2, 3]);
tf.pow(a, 2).print(); // [4, 9]
tf.sqrt(a)
Racine carrée de chaque élément.
const a = tf.tensor([4, 9]);
tf.sqrt(a).print(); // [2, 3]
tf.exp(a)
Exponentielle de chaque élément (e^x).
const a = tf.tensor([1, 2]);
tf.exp(a).print();
tf.log(a)
Logarithme naturel de chaque élément.
const a = tf.tensor([1, 10]);
tf.log(a).print();
tf.abs(a)
Valeur absolue de chaque élément.
const a = tf.tensor([-1, 2]);
tf.abs(a).print(); // [1, 2]
tf.neg(a)
Inverse les signes.
const a = tf.tensor([5, -7]);
tf.neg(a).print(); // [-5, 7]

Création de modèles avec tf.sequential()

tf.sequential()
Crée un modèle séquentiel, dans lequel les couches sont empilées linéairement.
const model = tf.sequential();
model.add(tf.layers.dense({ units: 1, inputShape: [1] }));
model.add(layer)
Ajoute une couche au modèle. Exemple avec 2 couches :
const model = tf.sequential();
model.add(tf.layers.dense({ units: 10, activation: 'relu', inputShape: [2] }));
model.add(tf.layers.dense({ units: 1 }));

Compilation et entraînement

model.compile()
Prépare le modèle avec une fonction de perte, un optimiseur, et des métriques.
model.compile({
  optimizer: 'sgd',
  loss: 'meanSquaredError',
  metrics: ['mse']
});
model.fit(x, y, options)
Entraîne le modèle sur les données x et y.
const xs = tf.tensor2d([[1], [2], [3], [4]]);
const ys = tf.tensor2d([[2], [4], [6], [8]]);
await model.fit(xs, ys, {
  epochs: 100,
  callbacks: {
    onEpochEnd: (epoch, logs) => console.log('Epoch ' + epoch, logs.loss)
  }
});

Prédiction avec model.predict()

model.predict(x)
Utilise le modèle entraîné pour faire une prédiction.
const prediction = model.predict(tf.tensor2d([[5]]));
prediction.print(); // devrait donner ~10

Sauvegarde et chargement de modèles

model.save('localstorage://nom')
Sauvegarde le modèle dans le navigateur (ou IndexedDB).
await model.save('localstorage://mon-modele');
tf.loadLayersModel()
Charge un modèle sauvegardé.
const model = await tf.loadLayersModel('localstorage://mon-modele');

Visualisation avec tfjs-vis

tfvis.show.modelSummary()
Affiche un résumé du modèle dans le navigateur.
tfvis.show.modelSummary({ name: 'Résumé du modèle' }, model);
tfvis.show.history()
Affiche la progression de l'entraînement (loss, accuracy...)
const history = await model.fit(xs, ys, { epochs: 50 });
tfvis.show.history(
  { name: 'Historique de l\'apprentissage' },
  history,
  ['loss']
);
tfvis.render.scatterplot()
Affiche un nuage de points (utile pour visualiser données d’entrée/sortie).
tfvis.render.scatterplot(
  { name: 'Données' },
  { values: [{ x: 1, y: 2 }, { x: 2, y: 4 }] },
  { xLabel: 'x', yLabel: 'y' }
);

Utilisation de tf.data

tf.data.csv()
Charger un fichier CSV pour entraîner un modèle.
const data = tf.data.csv('data.csv');
data.forEachAsync(row => console.log(row));

Prétraitement des données

normalisation
Mettre les données à l'échelle pour améliorer l'entraînement.
const normalized = data.sub(data.min()).div(data.max().sub(data.min()));

Fonctions personnalisées

Fonction de perte personnalisée
Créer une fonction de perte adaptée à ton problème.
const customLoss = (yTrue, yPred) => tf.losses.meanSquaredError(yTrue, yPred);
model.compile({ loss: customLoss });

Callbacks personnalisés

onEpochEnd
Afficher la perte après chaque époque.
await model.fit(xs, ys, {
  epochs: 100,
  callbacks: {
    onEpochEnd: (epoch, logs) => {
      console.log(`Epoch ${epoch + 1} - Loss: ${logs.loss}`);
    }
  }
});

Modèles pré-entraînés

@tensorflow-models/mobilenet
Utiliser un modèle pré-entraîné pour la classification d'image.
import * as mobilenet from '@tensorflow-models/mobilenet';
const model = await mobilenet.load();
const prediction = await model.classify(imgElement);

Webcam / Audio / Canvas

tf.browser.fromPixels()
Capturer une image depuis la webcam et prédire en temps réel.
const img = tf.browser.fromPixels(videoElement).resizeBilinear([224, 224]).expandDims(0);
const prediction = model.predict(img);

Déploiement d'un modèle formé ailleurs

tensorflowjs_converter
Convertir un modèle Python vers TensorFlow.js pour le web.
tensorflowjs_converter --input_format=tf_saved_model ./mon_modele ./modele_tfjs

Performance et mémoire

tf.memory(), .dispose()
Surveiller et libérer la mémoire utilisée par les tenseurs.
console.log(tf.memory());
tensor.dispose();