PyBrain - Module d'apprentissage par renforcement

L'apprentissage par renforcement (RL) est une partie importante de l'apprentissage automatique. L'apprentissage par renforcement permet à l'agent d'apprendre son comportement en fonction des intrants de l'environnement.

Les composants qui interagissent les uns avec les autres pendant le renforcement sont les suivants -

Environment
Agent
Task
Experiment

La disposition de l'apprentissage par renforcement est donnée ci-dessous -

Dans RL, l'agent parle avec l'environnement par itération. A chaque itération, l'agent reçoit une observation qui a la récompense. Il choisit ensuite l'action et l'envoie à l'environnement. L'environnement à chaque itération passe à un nouvel état et la récompense reçue à chaque fois est enregistrée.

Le but de l'agent RL est de collecter autant de récompenses que possible. Entre les itérations, la performance de l'agent est comparée à celle de l'agent qui agit correctement et la différence de performance donne lieu à une récompense ou à un échec. RL est essentiellement utilisé dans les tâches de résolution de problèmes telles que le contrôle du robot, l'ascenseur, les télécommunications, les jeux, etc.

Voyons comment travailler avec RL dans Pybrain.

Nous allons travailler sur le labyrinthe environmentqui sera représenté en utilisant un tableau numpy à 2 dimensions où 1 est un mur et 0 est un champ libre. La responsabilité de l'agent est de se déplacer sur le terrain libre et de trouver le point de but.

Voici un flux de travail étape par étape avec l'environnement de labyrinthe.

Étape 1

Importez les packages dont nous avons besoin avec le code ci-dessous -

from scipy import *
import sys, time
import matplotlib.pyplot as pylab # for visualization we are using mathplotlib

from pybrain.rl.environments.mazes import Maze, MDPMazeTask
from pybrain.rl.learners.valuebased import ActionValueTable
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, QLambda, SARSA #@UnusedImport
from pybrain.rl.explorers import BoltzmannExplorer #@UnusedImport
from pybrain.rl.experiments import Experiment
from pybrain.rl.environments import Task

Étape 2

Créez l'environnement de labyrinthe en utilisant le code ci-dessous -

# create the maze with walls as 1 and 0 is a free field
mazearray = array(
   [[1, 1, 1, 1, 1, 1, 1, 1, 1],
   [1, 0, 0, 1, 0, 0, 0, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 1, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 0, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 1, 1]]
)
env = Maze(mazearray, (7, 7)) # create the environment, the first parameter is the 
maze array and second one is the goal field tuple

Étape 3

L'étape suivante consiste à créer l'agent.

L'agent joue un rôle important dans RL. Il interagira avec l'environnement du labyrinthe en utilisant les méthodes getAction () et integrObservation ().

L'agent a un contrôleur (qui mappera les états aux actions) et un apprenant.

Le contrôleur dans PyBrain est comme un module, pour lequel l'entrée est des états et les convertit en actions.

controller = ActionValueTable(81, 4)
controller.initialize(1.)

le ActionValueTablenécessite 2 entrées, c'est-à-dire le nombre d'états et d'actions. L'environnement de labyrinthe standard comporte 4 actions: nord, sud, est, ouest.

Nous allons maintenant créer un apprenant. Nous allons utiliser l'algorithme d'apprentissage SARSA () pour l'apprenant à utiliser avec l'agent.

learner = SARSA()
agent = LearningAgent(controller, learner)

Étape 4

Cette étape ajoute l'agent à l'environnement.

Pour connecter l'agent à l'environnement, nous avons besoin d'un composant spécial appelé tâche. Le rôle d'untask est de rechercher le but dans l'environnement et comment l'agent obtient des récompenses pour ses actions.

L'environnement a sa propre tâche. L'environnement Maze que nous avons utilisé a la tâche MDPMazeTask. MDP signifie“markov decision process”ce qui signifie que l'agent connaît sa position dans le labyrinthe. L'environnement sera un paramètre de la tâche.

task = MDPMazeTask(env)

Étape 5

La prochaine étape après l'ajout de l'agent à l'environnement consiste à créer une expérience.

Maintenant, nous devons créer l'expérience, afin que nous puissions avoir la tâche et l'agent coordonnés les uns avec les autres.

experiment = Experiment(task, agent)

Nous allons maintenant exécuter l'expérience 1000 fois comme indiqué ci-dessous -

for i in range(1000):
   experiment.doInteractions(100)
   agent.learn()
   agent.reset()

L'environnement s'exécutera 100 fois entre l'agent et la tâche lorsque le code suivant sera exécuté -

experiment.doInteractions(100)

Après chaque itération, il redonne un nouvel état à la tâche qui décide quelles informations et récompenses doivent être transmises à l'agent. Nous allons tracer une nouvelle table après avoir appris et réinitialisé l'agent dans la boucle for.

for i in range(1000):
   experiment.doInteractions(100)
   agent.learn()
   agent.reset()
   pylab.pcolor(table.params.reshape(81,4).max(1).reshape(9,9))
   pylab.savefig("test.png")

Voici le code complet -

Exemple

maze.py

from scipy import *
import sys, time
import matplotlib.pyplot as pylab

from pybrain.rl.environments.mazes import Maze, MDPMazeTask
from pybrain.rl.learners.valuebased import ActionValueTable
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, QLambda, SARSA #@UnusedImport
from pybrain.rl.explorers import BoltzmannExplorer #@UnusedImport
from pybrain.rl.experiments import Experiment
from pybrain.rl.environments import Task

# create maze array
mazearray = array(
   [[1, 1, 1, 1, 1, 1, 1, 1, 1],
   [1, 0, 0, 1, 0, 0, 0, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 1, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 0, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 1, 1]]
)
env = Maze(mazearray, (7, 7))

# create task
task = MDPMazeTask(env)

#controller in PyBrain is like a module, for which the input is states and 
convert them into actions.
controller = ActionValueTable(81, 4)
controller.initialize(1.)

# create agent with controller and learner - using SARSA()
learner = SARSA()

# create agent
agent = LearningAgent(controller, learner)

# create experiment
experiment = Experiment(task, agent)

# prepare plotting
pylab.gray()
pylab.ion()

for i in range(1000):
experiment.doInteractions(100)

agent.learn()
agent.reset()

pylab.pcolor(controller.params.reshape(81,4).max(1).reshape(9,9))
pylab.savefig("test.png")

Production

python maze.py

La couleur du champ libre sera modifiée à chaque itération.