[Sim.] Agents cognitifs simples (#2)

Bob, dont le comportement est décrit dans ce précédent billet, a maintenant avec lui Lauren, qui utilise l’odorat pour se diriger. Elle est bien plus petite que Bob et doit s’éloigner de son passage, elle peut en mourir. Les deux co-habitent désormais et la distribution de nourriture est automatisée. Leurs deux réseaux de neurones sont placés à gauche, avec leurs barres de faim (voir le billet sur Bob).

Bob va maintenant plus rapidement quand il a faim et les deux agents ont un temps perceptif différent (voir Milieu animal et milieu humain d’Uexküll). Lauren bouge moins et a un réseau neuronal plus simple, elle ne fait grosso modo que s’éloigner des mauvaises odeurs (danger de Bob) et de s’approcher des bonnes (nourriture quand elle a faim). Elle possède trois inputs qui correspondent respectivement à : l’odeur de Bob qui s’approche, l’odeur de la nourriture qui est présente et la faim. Bob utilise ses yeux et son antenne, tandis que Lauren utilise seulement son nez.

L’applet

Le but était de simuler de l’intéraction entre deux agents autonomes.

[Sim.] Carte auto organisatrice

 

Dans cette simulation, le but était de programmer une carte auto organisatrice en utilisant le modèle du statisticien finlandais Teuvo Kohonen (1984).

L’algorithme du réseau Kohonen classe de manière non supervisée de petits vecteurs (2 ou 3 nombres pour notre simulation). En effet, chaque neurone est associé à un vecteur, par exemple, une position dans un plan en 2 dimensions, ou encore, le code d’une couleur au format RGB.

Le fonctionnement est plutôt simple. Prenons l’exemple d’en plan en 2d. À chaque step :

1) On envoie un point au hasard sur le plan, à l’intérieur d’une forme prédéfinie, à la couche d’entrée du réseau.
2) Le réseau commence par détecter le neurone dont le point est le plus près de celui passé en entrée.
3) Une zone de “voisins” autour de ce point est déterminée et
4) chaque neurone à l’intérieur de cette zone verra ses poids ajustés en fonction de l’input.

Ce processus répété jusqu’à un certain point donne au réseau une connaissance topologique suffisante pour établir une carte de manière autonome sur la forme prédéfinie.

La simulation en 2d (vidéo)

La simulation (applets)

Le mieux c’est de voir l’auto organisation en temps réel :

Version en 2d : Kohonen en deux dimensions (Java)

Version en 3d : Kohonen en trois dimensions (Java)

Une image

Un simple plan carré, mais avec une profondeur du centre vers les côtés. Kohonen en 3d, ici la carte est de 100×100 et on voit sur le plan en 2d le classement des couleurs.

[Sim.] Agent cognitif simple

Pour cette expérimentation, le but était d’utiliser un réseau neuronal simple qui permette à Bob de survivre dans son environnement. La tâche qu’il devait remplir est inspirée de la première tâche d’Ernest: Bob devait pouvoir atteindre la nourriture dans un espace libre.

Le modèle utilisé comprend 4 inputs et, après les couches cachées, 2 outputs. Les 4 inputs correspondent respectivement à :

1) nourriture détectée par l’oeil gauche,
2) nourriture détectée par l’oeil droit,
3) bob ressent de la faim, et
4) bob ressent (antenne) qu’il touche à un mur en face de lui.

À partir de ces 4 inputs, Bob doit retourner l’action qu’il entreprendra :

00 = tout droit,
01 = “U Turn”,
10 = tourne à gauche, et
11 = tourne à droite.

Armé des opérateurs possibles dans ce type de réseau, le modèle de Bob répond parfaitement à cette tâche :

SI nourriture détectée dans un seul oeil (XOR) 
Et (AND) SI la faim est ressentie :
—> Tourne toi vers la nourriture et avance d’une case (10 ou 11)

SINON, SI l’agent fait face à un mur :
—> Tourne toi en sens contraire (01)

SINON
—> Avance tout droit (00)

Le modèle comprend 4 couches, qui, de l’input à l’output contiennent 4, 5, 3 et 2 neurones. Chaque neurone est connecté avec chaque neurone de la couche suivante, jusqu’à l’output. Le seuil est le même pour chacun (0.5), les poids sont déterminés pour répondre comme l’algorithme.

L’expérience en images :

1) L’input de Bob est 0 1 1 0 (première colonne) donc il détecte de la nourriture dans l’oeil droit et il a faim. L’output est 1 1 (dernière colonne), il effectuera donc un virage à droite au step suivant.

2) Bob détecte la nourriture dans l’oeil gauche (1000), mais n’a pas faim (barre verte au-dessus de 70%). Il continue donc sans donner d’attention (00).

3) Bob qui arrive face à un mur avec aucune nourriture à l’horizon. Il renvoit 01, il effectuera donc un inversement de direction le step suivant.

L’applet Java :

L’applet est disponible à cette adresse.

Un clic gauche sur le terrain ajoute de la nourriture, alors qu’un clic droit l’enlève. Si la barre verte se vide, Bob meurt. On peut alors le nourrir pour le ramener à la vie en cliquant sur lui.

[Sim.] Reconnaissance de patterns

Le réseau de Hopfield est un modèle qui apprend à reconnaître des patterns (images en noir & blanc). Dans ce modèle, tous les neurones sont interconnectés et chaque neurone est à la fois un input et un output. Plus le nombre de neurones est grand, plus le nombre de patterns que le réseau peut apprendre est lui-aussi grand.

Ainsi, dans un 10×10, il est possible d’apprendre 4 ou 5 patterns. Là où le réseau devient intéressant, c’est qu’il peut reconnaître une image même si on lui en fournit une version corrompue.

La simulation (ne nécessite aucun plugin)

Aller à cette page (s’ouvre dans une nouvelle fenêtre) et suivre les étapes suivantes :

1) Cliquer sur “Train”
2) Cliquer sur “Select” et choisir une nouvelle image
3) Répéter les étapes 1 & 2 et cliquer sur “Train” une dernière fois.
— Le réseau a maintenant appris 3 patterns —

Ensuite, pour tester les capacités du réseau, on sélectionne un pattern appris et on teste sa résistance à la corruption en cliquant plusieurs fois sur “Corrupt” et en alternant avec “Run”, qui permet de voir ce que le réseau renvoit.

La simulation en vidéo