---
title: Brain.js réseau de neurones et Javascript
tags: data, ia
robots: noindex, nofollow
author: Julien Noyer
---
# Réseau de neurones et Javascript
*Quand Javascript vient en aide à l'IA*
> © [Julien Noyer](https://www.linkedin.com/in/julien-n-21219b28/) - All rights reserved for educational purposes only
---
## Introduction
[Brain.js](https://brain.js.org/#/) est une librairie à la fois FrontEnd et Backend permettant de créer des réseaux de neurones, de les entraîner et de les utiliser dans le but de réaliser des prédictions. L'intérêt de cette librairie est qu'elle est particulièrement simple à manipuler et qu'elle permet d'appréhender les différentes notions concernant les réseaux de neurones.
## Utilisation de Brain.js en FrontEnd
Dans la mesure ou [Brain.js](https://brain.js.org/#/) est une librairie, il faut, pour pouvoir l'utiliser dans une page Web, importer un script Javascript avant le script de la page. Vous devez donc dans un premier temps télécharger le fichier en [cliquant sur ce lien](https://bit.ly/39xOFm9) puis créer une page HTML qui contient le code suivant :
```html
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>BrainJS : installation FrontEnd</title>
</head>
<body>
<h1>BrainJS : installation FrontEnd</h1>
<script src="./js/brain.js"></script>
<script>
// Afficher l'objet brain dans la console
console.log(brain);
</script>
</body>
</html>
```
## Utilisation de Brain.js en BackEnd
Pour utiliser [Brain.js](https://brain.js.org/#/) en BackEnd vous devez dans un premier temps installer [NodeJS](https://nodejs.org/en/) et [NPM](https://www.npmjs.com/) en suivant les instructions indiquez sur [ce lien](https://www.npmjs.com/get-npm). Une fois votre machine configurée, vous devez créer un dossier depuis votre [IDE](https://bit.ly/3odUsRT), par exemple [Visual Studio Code](https://code.visualstudio.com), puis via votre terminal vous placer dans le dossier créé et taper les commandes :
```bash
touch server.js
npm init
npm i brain.js
```
Dans ce même dossier, vous devez ensuite créer un fichier `server.js` contenant le code suivant :
```javascript
// Importer Brain.js
const brain = require('brain.js');
// Afficher l'objet Brain dans la console
console.log(brain)
```
> Pour tester votre code vous devez taper dans votre terminal la commande `npm start`
Les codes qui sont présentés dans ce document sont à la fois réalisables en FrontEnd et en BackEnd, mais nous partirons du principe que pour réaliser des calculs gourmant en énergie, il est préférable d'utiliser l'environnement [NodeJS](https://nodejs.org/en/) car il s'exécute cotés serveur.
---
# Utilisation d'un réseau de neurones
## Configuration du réseau de neurones
Un [réseau de neurones](https://bit.ly/3olvFvz) est constitué de différentes couches dans lesquelles les neurones artificiels intéragissent ensemble pour analyser des données en entrées - appelée *input* - dans le but de comprendre un résultat - appelé *output*. Sur ce point, il est important de constaté que c'est le cerveau humain qui défini à la fois les *inputs* et les *output*, mais que c'est la machine qui calcule les *distances* entre les différents *inputs*, nous applellons ce principe "*l'apprentissage supervisé*". Plus la machine s'entraine, plus elle donne un résultat juste, mais à l'instar d'un professeur nous devons définir le niveau de compréhention acceptable avant de concidérer que la machine à suffisemment compris les données à analyser. Le code suivant défini le [réseau de neurones](https://bit.ly/3olvFvz) que nous allons utiliser dans ce document :
```javascript
// Importer Brain.js
const brain = require('brain.js');
// Création du réseau de neurones
const NeuralNetwork = new Brain.NeuralNetwork({
activation: 'sigmoid',
hiddenLayers: [2],
iterations: 3000,
learningRate: 0.5
});
```
> Les différentes options possibles sont définies sur [ce lien](https://bit.ly/37uNxx9).
## Définition des données d'entraînement
Pour entraîner un [réseau de neurones](https://bit.ly/3olvFvz) nous devons disposer de données classifier, c'est-à-dire que c'est à nous de définir se que les données représentent et le résultat que nous attendons. L'un des exercices de bases en intelligence artificielle est celui qui prend en compte des données physiques d'iris - la fleur - qui correspondent à différents types. Le jeu de données que nous allons utiliser est disponible sur le site [Kaggle](https://www.kaggle.com/) au format CSV. Vous pouvez le télécharger en [cliquant ici](https://www.kaggle.com/uciml/iris) et voici une partie des données que nous allons traiter :
```csv
Id,SepalLengthCm,SepalWidthCm,PetalLengthCm,PetalWidthCm,Species
1,5.1,3.5,1.4,0.2,Iris-setosa
57,6.3,3.3,4.7,1.6,Iris-versicolor
115,5.8,2.8,5.1,2.4,Iris-virginica
```
Les informations qui nous intéressent sont celles qui correspondent aux différentes tailles et au type d'iris, car nous allons entraîner un réseau qui doit être capable de reconnaître un type d'iris selon des critères de taille.
Nous devons néanmoins convertir le fichier CSV en JSON et ne faire pas en sorte de transformer les types d'iris en entier. En effet, une machine est plus à l'aise avec des entiers plutôt que des chaîne de caractères, c'est pourquoi nous allons considérer que les types d'iris sont représentées en tableau de la manière suivante :
```javascript
[1, 0, 0] // Iris setosa
[0, 1, 0] // Iris versicolor
[0, 0, 1] // Iris virginica
```
> Notre réseau de neurones devra être capable de calculer les distances entre ces différents tableaux selon les valeurs de taille.
Comme précisé plut haut dans ce document, notre fichier JSON doit contenir des *inputs* et des *outputs*. Les *inputs* seront les informations sur les tailles et les *outputs* seront les tableaux qui correspondent au type d'iris. Notre fichier JSON doit donc correspondre au tableau suivant :
```json
[
{"input":[5.1,3.5,1.4,0.2],"output":[1,0,0]},
{"input":[6.3,3.3,4.7,1.6],"output":[0,1,0]},
{"input":[5.8,2.8,5.1,2.4],"output":[0,0,1]}
]
```
Une fois que nous avons traité la totalité du fichier CSV, nous devons le séparer en deux car nous devons disposer d'un fichier d'entrainenement et d'un fichier de test.
## Entrainer un réseau de neurones
Nous disposons à présent d'un fichier *train.json* et un fichier *test.json*, que nous intégrons dans un dossier data à la racine de notre projet. Nous allons éditer le fichier *server.js* pour entraîner notre réseau de neurones avec les fichier *train.js* de la manière suivante :
```javascript
// Importer Brain.js
const brain = require('brain.js');
// Création du réseau de neurones
const NeuralNetwork = new Brain.NeuralNetwork({
activation: 'sigmoid',
hiddenLayers: [2],
iterations: 3000,
learningRate: 0.5
});
// Importer les données d'entrainement
const trainData = require('./data/train.json');
// Entrainer le réseau de neurones
NeuralNetwork.train( trainData, {
log: true,
logPeriod: 10,
errorThresh: 0.002
});
```
> Les différentes options possibles sont définies sur [ce lien](https://github.com/BrainJS/brain.js#training-options).
L'option la plus importante à observer est celle qui permet de définir le niveau d'erreur acceptable, car nous ne considérons jamais qu'un réseau de neurones est capable de reconnaître à 100% les données, mais qu'il doit se tromper le moins possible.
## Tester un réseau de neurones
Nous allons à présenter utiliser le fichier *test.json* pour vérifier que si notre réseau de neurones est suffisemment entrainer pour reconnaître les types d'iris. Pour ce faire, nous allons effectuer une boucle sur la collection de données de la façon suivante :
```javascript
// Importer Brain.js
const brain = require('brain.js');
// Création du réseau de neurones
const NeuralNetwork = new Brain.NeuralNetwork({
activation: 'sigmoid',
hiddenLayers: [2],
iterations: 3000,
learningRate: 0.5
});
// Importer les données d'entrainement
const trainData = require('./data/train.json');
// Entrainer le réseau de neurones
NeuralNetwork.train( trainData, {
log: true,
logPeriod: 10,
errorThresh: 0.002
});
// Importer les données de test
const testData = require('./data/test.json');
// Tester le réseau de neurones
testData.forEach(data => {
const testedData = NeuralNetwork.run( data.input );
console.log(testedData)
});
```
Les données affichées dans la console ressemblent au tableau suivant :
```javascript
Float32Array [
0.9982905983924866,
0.001463170861825347,
0.0008319445187225938
]
```
Nous pouvons observer que le résultat affiché n'est jamais `[1,0,0]` mais une valeur qui par de `O` et cherche à se rapprocher de `1`, ne considérons donc que le taux d'erreur du réseau de neurones est acceptable pour identifier une *Iris setosa*, mais que le résultat est bien trop éloigner des deux autres types.
## Sauvegarder un modèle prédictif
Avons-nous besoin d'entrainer à chaque fois un réseau avant de l'utiliser ? La réponse est clairement non, car l'intérêt d'utiliser un réseau de neurones est de pouvoir créer un modèle afin de réaliser une [analyse prédictive](https://fr.wikipedia.org/wiki/Analyse_prédictive). Pour ce faire, nous allons , une fois le réseau de neurones entraîner, créer un modèle et l'enregistrer de la manière suivante :
```javascript
// Importer Brain.js
const brain = require('brain.js');
// Importer fs pour créer un fichier
const fs = require('fs');
// Création du réseau de neurones
const NeuralNetwork = new Brain.NeuralNetwork({
activation: 'sigmoid',
hiddenLayers: [2],
iterations: 3000,
learningRate: 0.5
});
// Importer les données d'entrainement
const trainData = require('./data/train.json');
// Entrainer le réseau de neurones
NeuralNetwork.train( trainData, {
log: true,
logPeriod: 10,
errorThresh: 0.002
});
// Enregistrement du modèle dans un dossier "net" exploitable en NodeJS
fs.writeFileSync(
'net/trained-model-node.js',
`module.exports = ${ NeuralNetwork.toFunction().toString() };`
);
// Enregistrement du modèle dans un dossier "net" exploitable en FrontEnd
fs.writeFileSync(
'net/trained-model-front.js',
`export default ${ NeuralNetwork.toFunction().toString() };`
);
```
> Le module [fs](https://nodejs.org/api/fs.html) est natif en NodeJS.
## Utiliser un modèle prédictif
Le fichier que nous avons précédemment enregistré contient une fonction que nous pouvons à présent utiliser dans un nouveau fichier. Nous allons créer un fichier nommé *test.js* qui contient le code suivant :
```javascript
// Importer le modèle
const trainedModel = require('./net/trained-model-node.js');
// Importer les données de test
const testData = require('./data/test.json');
// Utilser le modèle
testData.forEach(data => {
const testedData = trainedModel( data.input );
console.log(testedData);
});
```
> A cette étape nous n'avons plus besoin d'importer Brain.js
---
## Ressources
> Index des liens vers les sujets traités dans ce document :
- **Brain.js** https://brain.js.org/#/
- **Script Brain.js** https://bit.ly/39xOFm9
- **NodeJS** https://nodejs.org/en/
- **NPM** https://www.npmjs.com/get-npm
- **IDE** https://bit.ly/3odUsRT
- **Visual Studio Code** https://code.visualstudio.com
- **Réseau de neurones** https://bit.ly/3olvFvz
- **Apprentissage supervisé** https://bit.ly/3myWknZ
- **Kaggle** https://www.kaggle.com/
- **Analyse prédictive** https://fr.wikipedia.org/wiki/Analyse_prédictive
- **File System NodeJS** https://nodejs.org/api/fs.html
Sign in with Wallet
Connect another wallet