# data[].attributes.body
Le convolutional neural network est une forme spéciale du réseau neuronal artificiel. Il comporte plusieurs couches de convolution et est très bien adapté à l’apprentissage automatique et aux applications avec Intelligence artificielle (IA) dans le domaine de la reconnaissance d’images et de la parole, de la vente et du marketing ciblé et bien plus encore.

# data[].attributes.body
Pour convertir toutes les valeurs de type catégorie en valeurs numériques en remplaçant toutes les valeurs uniques par des nombres séquentiels :

cleanup_nums = {"Format": {"Big": 1, "Small": 2},
"Style": {"Serie": 1, "One Book": 2},
"Kind": {"Learning": 1, "Story": 2},
"Readers": {"Adults": 1, "Teenagers": 2, "Kids": 3}
}
data_frame.replace(cleanup_nums, inplace=True)

data_frame.head()

Pour le labo : https://www.researchgate.net/publication/318656107_Application_of_Artificial_Neural_Networks_in_Modeling_Direction_Wheelchairs_Using_Neurosky_Mindset_Mobile_EEG_Device

Les préparations sont les suivantes :

Initialisation  : Ils ont commencé par prendre des mesures avec un casque à méditation de données sur le cerveau d’une personne en situation d’handicap en fauteuil roulant afin de prédire la direction du fauteuil à l’aide du signal cérébral.

Les neurones se transmettent à 240km/h jusqu’à la moelle épinière. Sachant que le cerveau pèse 2% du poids corporel.

# data[].attributes.body
Une architecture de réseau de neurones convolutifs est formée par un empilement de couches de traitement :

la couche de convolution (CONV) qui traite les données d'un champ récepteur ;

la couche de pooling (POOL), qui permet de compresser l'information en réduisant la taille de l'image intermédiaire (souvent par sous-échantillonnage) ;

la couche de correction (ReLU), souvent appelée par abus « ReLU » en référence à la fonction d'activation (Unité de rectification linéaire) ;

la couche « entièrement connectée » (FC), qui est une couche de type perceptron ;

la couche de perte (LOSS).

Par exemple :

Combien de couches convolutives ? n = 6

Combien de kernels de convolution ou filtres par couche ? 2

Combien de couches de pooling ? 3 couches de pooling

Quel est le type de pooling utilisé ? Pooling de moyenne

# data[].attributes.body
Le perceptron multicouche (multilayer perceptron MLP) est un type de réseau neuronal artificiel organisé en plusieurs couches. L'information circule de la couche d'entrée vers la couche de sortie uniquement : il s'agit donc d'un réseau à propagation directe (feedforward). Chaque couche est constituée d'un nombre variable de neurones, les neurones de la dernière couche (dite « de sortie ») étant les sorties du système global.

# data[].attributes.body
Le perceptron est un algorithme d'apprentissage supervisé de classifieurs binaires (c'est-à-dire séparant deux classes).
Il s'agit d'un neurone formel muni d'une règle d'apprentissage qui permet de déterminer automatiquement les poids synaptiques de manière à séparer un problème d'apprentissage supervisé.

# data[].attributes.body
Labo colibri avec les MLAgents sur unity :
Le but est que le colibri réussisse à s'entraîner, à observer le monde, à prendre des mesures et à interagir avec d'autres objets.

Aussi avec FSM simulator nous avons fait des combinaisons en régex pour obtenir un graphique :

Par exemple :

Une regex qui représente la figure de si a = b.

Une regex qui améliore le programme avec les espaces : if((false_false+0_0))

# data[].attributes.body
//On importe la librairie mathématique :
import math
(Elle sert à calculer les racines carrées)
//Ensuite on déclare :
num_cells = math.ceil(math.sqrt(numbers_to_display))
Ici, le nombre de cellule est égale à math qui calcule, et on passe en paramètre le nombre d'affichage qui est 25.
//Puis on a :
math.ceil() qui permet d'envoyer le plus petit entier supérieur ou égal à x. Si x n'est pas un flottant, il délègue à x_ceil qui retourne une intégrale valeur.
math.sqrt() qui renvoie la racine carrée de 25 ici illustré par :
math.sqrt(numbers_to_display))
Sachant que numbers_to_display = 25
-------------------
math.dist() pour calculer la distance entre x et y par ex.
-------------------
math.comb(n, k) permet de renvoyer le nombre de façons de choisir k éléments parmi n éléments sans répétition et sans ordre.
-------------------
//Constante :
math.e (avec e = 2.718281)
math.pi (avec π = 3.141592)
math.tau (avec τ = 6.283185)
math.inf (avec float('inf'))
math.nan ()
Exemple :

import math
>>> math.nan == math.nan
False
>>> float('nan') == float('nan')
False
>>> math.isnan(math.nan)
True
>>> math.isnan(float('nan'))
True

# data[].attributes.body
Un GA (abréviation de « Genetic Algorithm ») est un type d’algorithmes un peu particulier, appartenant à la famille des algorithmes évolutionnistes. Le but des GA est de trouver une solution optimum à un problème, dans un temps raisonnable, en n’utilisant aucun algorithme précis.

Individu :

Un individu n’est rien de plus qu’un résultat. Quand on parle d’un individu en GA/GP, on parle en réalité d’une instance de la structure de données contenant un résultat, qu’il soit optimum ou non.

Population :

Une population n’est rien de plus qu’une collection, un regroupement d’individus.

Génération :

Une génération n’est rien de plus qu’une étape dans l’évolution d’une population. Comme dans la vraie vie.

Sélection :

La phase de sélection est une étape clef dans le fonctionnement des GA. C’est cette étape qui attribue un score à chaque individu en fonction de son adaptation au problème donné. Ce score est nommé « fitness » (= « aptitude pour … ») et en fonction des scores obtenus par chaque individu de la population, certains seront conservés pour la génération suivante et d’autres retourneront dans le néant.

Croisement :

Le croisement est une étape qui consiste à prendre deux individus différents et de les faire se reproduire pour générer de nouveau individu.

Mutation :

La mutation est une étape qui consiste à introduire aléatoire des modifications dans les constituants d’un individu.

Source : https://skyduino.wordpress.com/2015/07/16/tutorielpython-les-algorithmes-genetiques-garantis-sans-ogm/#:~:text=Un%20GA%20(abr%C3%A9viation%20de%20%C2%AB%20Genetic,n'utilisant%20aucun%20algorithme%20pr%C3%A9cis.https://skyduino.wordpress.com/2015/07/16/tutorielpython-les-algorithmes-genetiques-garantis-sans-ogm/#:~:text=Un%20GA%20(abr%C3%A9viation%20de%20%C2%AB%20Genetic,n'utilisant%20aucun%20algorithme%20pr%C3%A9cis.

# data[].attributes.body
Les machines à états finis (FSM) sont des modèles de calcul définis par une liste d'états d'ensemble uniques qui ne peuvent être choisis qu'un par un.

Au départ on initialise avec :
def __init__(self):
|     self.matrice = {"FAIM" : {"recevoir-nourriture" : "BIEN", "ennemi-arrive" : "PEUR", "ami-arrive" : "FAIM", "ennemi-quitte" : "FAIM"},

Ensuite on fait subir un tableau d'évènement et d'état c'est-à-dire self-etat = "FAIM"

Puis, on retourne cet état en la récupérant.
Il peut y avoir plusieurs états qui sont :
etat = agent.subir("ennemi-arrive")
etat = agent.subir("recevoir-nourriture")
etat = agent.subir("ami-arrive")
etat = agent.subir("ennemi-quite")

# data[].attributes.body
Il contient la séquence générale des étapes suivies par un GA, donc initialiser la population, évaluer l'aptitude, reproduire et répéter, mais vous permet de personnaliser le GA pour votre application particulière par substitution.
On utilise le modèle : GeneticAlgothim()

# data[].attributes.body
C'est le fait d'imiter un comportement de la vie réel. Une machine qui parle comme un humain (Robot Humanoïde)

# data[].attributes.body
Il fallait simuler un vol d'oiseau sur unity dans ce labo.
Il est important de :
- Calculer l'alignement
- Calculer la cohesion
- Calculer la separation

1.a) Les formats de données :
Vector2 --> Cette structure permet de représenter les position 2D comme la texture des oiseaux et leur comportement sur l'axe X et Y.
Vector3 --> Il permet de connaître la position et la vitesse de l'oiseau.
Transform --> Il permet d'avoir la position, la rotation, et l'échelle de l'oiseau. (Transform[]  transformeeOiseaux, transformeeVoliere;)

1.b)
Le tableau float : Transform[] transformeeOiseaux, transformeeVoliere;

1.c)
Les fonctions et opérations mathématiques utilisées dans le code :
float() qui permet l'utilisation des nombres à virgule pour préciser la vitesse de 3.0f par exemple.

////////////////////
Pour le labo aquarium il fallait utiliser node :
PROCEDURE pour installer une autre version de node avec nvm !!!

Telecharger nvm
https://github.com/coreybutler/nvm-windows/releases/download/1.1.9/nvm-setup.exe
Installer dans C:\Program Files\nodejsx\nvm indiquer pour le symlink C:\Program Files\nodejs
s'assurer que la variable d'environnement NVM_HOME pointe sur C:\Program Files\nodejsx\nvm
et que NVM_SYMLINK pointe sur C:\Program Files\nodejs

=> REDEMARRER

Entrer en mode administrateur dans la console de windows (CMD) --> Important sinon l'installation est refusé.

nvm install 16.14.0
nvm use 16.14.0
cd le-projet
npm install .
npm start
browser localhost:3000