---
# System prepended metadata

title: 6 - BrainJS initiation
tags: [ia, ' data']

---

---
title: 6 - BrainJS initiation
tags: ia, data
robots: noindex, nofollow
author: Julien Noyer
---

# Brain.js : réseau de neurones en Javascript

![](https://i.imgur.com/fixiJuM.png)

[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 entrainer 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 convernant les réseaux de neurones.

<br>

## Utilisation de Brain.js en FrontEnd

Dans la mesur 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 : 

```htmlembedded=
<!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>
```

<br>

## Utilisation de Brain.js en BackEnd

Pour utiliser [Brain.js](https://brain.js.org/#/) en BackEnd vous devez dans un permier temps intaller [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ésentez dans ce document sont à la fois réalisables en FrontEnd et en BackEnd mais nous partirons du principe que pour réaliser des calcules 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.

---

<br><br><br>

# Utilisation d'un réseau de neurones

![](https://i.imgur.com/qiPgHTp.png)

## 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 - applé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).

<br>

## Définition des données d'entrainement

Pour entrainer un [réseau de neurones](https://bit.ly/3olvFvz) nous devons disposer de données classiffier, 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 exercice de bases en intelligence artificielle est celui qui prend en compte des données physiques d'iris - la fleur - qui correspondent à différents type. Le jeu de données que nous allons utilisé sont disponibles 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 voiçi 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 entrainer un réseau qui doit être capable de reconnaitre un type d'iris selon des critère de taille.

Nous devons néanmoins convertir le fichier CSV en JSON et ne faire en sorte de transformer les type d'iris en entier. En effet, une machine est plus à l'aise avec des entiers plutôt que des chaine de caractères, c'est pourquoi nous allons concidé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 tableau selon les valeurs de taille.

Comme préciser 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 tableau 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'entrainenemtn et d'un fichier de test.

<br>

## 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 entrainer 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 reconnaitre à 100% les données mais qu'il doit se tromper le moins possible.

<br>

## 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 suddifemment entrainer pour reconnaître les type d'iris. Pur 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 ressemble 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 charche à 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 eux autres types.

<br>

## Sauvegarder un modèle prédictif

Avons-nous besoin d'ntrainer à chaque fois un réseau avant de l'utiliser ? La réponse est clairement non car l'intéret 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 entrainer, 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.

<br>

## Utiliser un modèle prédictif

Le fichier que nous avons précédemment enregistré conteint 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

---

<br><br><br>

# Ressources

![](https://i.imgur.com/WMir0gH.jpg)

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