Apprentissage par renforcement

Ce TP consiste à écrire en R un programme qui implante le Q-learning pour apprendre à sortir d'un labyrinthe, puis à expérimenter avec ce programme.

On va s'en tenir à une version élémentaire du Q-Learning. Des tas d'améliorations sont possibles pour en améliorer les performances.

Environnement fourni

Pour simplifier la réalisation de votre programme, je vous fournis un fichier avec un ensemble de fonctions R qui prennent en charge le labyrinthe et l'interaction entre l'agent et le labyrinthe. Il ne vous reste plus qu'à implanter ce que doit faire l'agent, comment il apprend.

Le contenu de ce fichier est le suivant :

Les états correspondent aux cases des couloirs du labyrinthe. Elles sont numérotés de manière arbitraire. L'une est la case départ, une autre est la case à atteindre.
Dans chaque case, l'agent peut effectuer un mouvement dans une case adjacente (du moment que ce n'est pas un mur).

action 1 : aller dans la case à gauche de la case courante.
action 2 : aller dans la case à droite de la case courante.
action 3 : aller dans la case au-dessus de la case courante.
action 4 : aller dans la case en-dessous de la case courante.

Dans ce fichier, on a :

la variable etat.initial contient le numéro de la case de départ dans le labyrinthe.
la variable sortie contient le numéro de la case qui doit être atteinte.
la variable nb.cases contient le nombre de cases/états.
la fonction actions.possibles (etat) renvoie un vecteur avec les numéros de mouvements possibles dans l'état passé en paramètre.
etat aune valeur comprise entre 1 et nb.cases.
la fonction transition (etat.courant, action) qui renvoie une liste composée de deux éléments : l'état atteint quand on réalise l'action indiquée dans l'état courant et le retour obtenu lors de cette transition. Si l'action est impossible dans cet état, l'état demeure inchangé.
etat aune valeur comprise entre 1 et nb.cases.
action vaut 1, 2, 3 ou 4.
une fonction which.is.max() que vous utilisez à la place de which.max().

Vous n'avez rien d'autre à savoir sur le contenu de ce fichier pour réaliser le TP. Pas la peine de regarder son contenu ; il vous suffit d'utiliser les variables et fonctions que je liste ci-dessus.
Vous prendrez soin de faire un source ("https://philippe-preux.github.io/ensg/miashs/rnf/tps/rl/laby.squelette.R") avant de commencer.

Q-Learning

Reste à implanter un Q-Learning qui apprend à sortir de ce labyrinthe.

# initialisations
Q <- matrix (0, nrow = nb.cases, ncol = 4)
nombre.de.pas <- 0
etat.courant <- etat.initial
# effectuer un épisode
while (etat.courant != sortie) {
     # choisir l'action à réaliser dans l'état courant
     action <- choix.action (etat.courant)
     # réaliser cette action et observer l'état suivant et le retour
     consequences <- transition (etat.courant, action)
     # mettre à jour la qualité du couple (etat.courant, action)
     ...
     etat.courant <- consequences$etat.suivant
     nombre.de.pas <- nombre.de.pas + 1
}

Il vous reste à :

écrire la fonction choix.action (). Un choix ε-glouton convient parfaitement ici. Prenez ε égal à 0,9 par exemple (à interprêter comme : la probabilité de choix de l'action aléatoire est 90%).
écrire la mise à jour indiquée par les ...

Exécuter ce programme et voir au bout de combien de pas il s'arrête.

Quand cela fonctionne, mettez tout cela dans une boucle pour effectuer un certain nombre d'épisodes (par exemple 100). C'est intéressant de stocker le nombre de pas effectués à chaque épisode pour pouvoir tracer une courbe d'apprentissage. Par exemple, j'ai obtenu la courbe suivante :

Quand vous faites plusieurs épisodes, c'est bien de diminuer la valeur de ε après chaque épisode, par exemple en multipliant sa valeur par 0,95 pour le faire diminuer doucement.

laby.1bis	laby.2bis	laby.4bis	laby.aeac2015