L'apprentissage automatique (ML) a rapidement transformé le monde du développement logiciel. Jusqu'à récemment, Python était le langage dominant dans l'espace ML, grâce à des bibliothèques comme TensorFlow et PyTorch. Mais avec l'essor de TensorFlow.js, les développeurs JavaScript peuvent désormais se plonger dans le monde passionnant du machine learning, en utilisant une syntaxe familière pour créer et entraîner des modèles directement dans le navigateur ou sur Node.js.

Dans cet article de blog, nous explorerons comment vous pouvez démarrer avec l'apprentissage automatique à l'aide de JavaScript. Nous allons passer en revue un exemple de création et de formation d'un modèle simple à l'aide de TensorFlow.js.

Pourquoi TensorFlow.js ?

TensorFlow.js est une bibliothèque open source qui vous permet de définir, d'entraîner et d'exécuter des modèles d'apprentissage automatique entièrement en JavaScript. Il fonctionne à la fois dans le navigateur et sur Node.js, ce qui le rend incroyablement polyvalent pour un large éventail d'applications ML.

Voici quelques raisons pour lesquelles TensorFlow.js est passionnant :

1. Formation en temps réel : vous pouvez exécuter des modèles directement dans le navigateur, offrant ainsi une interactivité en temps réel.
2. Multiplateforme : le même code peut s'exécuter à la fois sur les environnements serveur et client.
3. Accélération matérielle : il utilise WebGL pour l'accélération GPU, ce qui accélère les calculs.

Voyons par où commencer !

1. Configuration de TensorFlow.js

Avant de plonger dans le code, vous devrez installer TensorFlow.js. Vous pouvez l'inclure dans votre projet via une balise

Configuration du navigateur

Pour utiliser TensorFlow.js dans le navigateur, incluez simplement la balise

Configuration de Node.js

Pour un environnement Node.js, vous pouvez l'installer en utilisant npm :

npm install @tensorflow/tfjs

2. Construire un modèle de réseau neuronal simple

Créons un réseau neuronal simple qui prédit la sortie d'une fonction linéaire de base, y = 2x - 1. Nous utiliserons TensorFlow.js pour créer et entraîner ce modèle.

Étape 1 : Définir le modèle

Nous allons commencer par définir un modèle séquentiel (une pile linéaire de couches) avec une couche dense :

// Import TensorFlow.js
import * as tf from '@tensorflow/tfjs';

// Create a simple sequential model
const model = tf.sequential();

// Add a single dense layer with 1 unit (neuron)
model.add(tf.layers.dense({units: 1, inputShape: [1]}));

Ici, nous avons créé un modèle avec une couche dense. La couche possède un neurone (unités : 1) et attend une seule fonctionnalité d'entrée (inputShape : [1]).

Étape 2 : Compiler le modèle

Ensuite, nous compilons le modèle en spécifiant l'optimiseur et la fonction de perte :

// Compile the model
model.compile({
  optimizer: 'sgd',  // Stochastic Gradient Descent
  loss: 'meanSquaredError'  // Loss function for regression
});

Nous utilisons l'optimiseur Stochastic Gradient Descent (SGD), qui est efficace pour les petits modèles. La fonction de perte, MeanSquaredError, est appropriée pour les tâches de régression comme celle-ci.

Étape 3 : préparer les données de formation

Nous allons maintenant créer des données d'entraînement pour la fonction y = 2x - 1. Dans TensorFlow.js, les données sont stockées dans des tenseurs (tableaux multidimensionnels). Voici comment nous pouvons générer des données d'entraînement :

// Generate some synthetic data for training
const xs = tf.tensor2d([0, 1, 2, 3, 4], [5, 1]);  // Inputs (x values)
const ys = tf.tensor2d([1, 3, 5, 7, 9], [5, 1]);  // Outputs (y values)

Dans ce cas, nous avons créé un tenseur xs avec des valeurs d'entrée (0, 1, 2, 3, 4) et un tenseur de sortie correspondant ys avec des valeurs calculées en utilisant y = 2x - 1.

Étape 4 : Former le modèle

Maintenant, nous pouvons entraîner le modèle sur nos données :

// Train the model
model.fit(xs, ys, {epochs: 500}).then(() => {
  // Once training is complete, use the model to make predictions
  model.predict(tf.tensor2d([5], [1, 1])).print();  // Output will be close to 2*5 - 1 = 9
});

Ici, nous entraînons le modèle pendant 500 époques (itérations sur les données d'entraînement). Après la formation, nous utilisons le modèle pour prédire la sortie pour une valeur d'entrée de 5, qui devrait renvoyer une valeur proche de 9 (y = 2*5 - 1 = 9).

3. Exécution du modèle dans le navigateur

Pour exécuter ce modèle dans le navigateur, vous aurez besoin d'un fichier HTML contenant la bibliothèque TensorFlow.js et votre code JavaScript :

    
Simple Neural Network with TensorFlow.js

Et dans votre fichier app.js, vous pouvez inclure le code de création de modèle et de formation ci-dessus.