PyBrain - Módulo de aprendizaje por refuerzo

El aprendizaje por refuerzo (RL) es una parte importante del aprendizaje automático. El aprendizaje por refuerzo hace que el agente aprenda su comportamiento basándose en las aportaciones del entorno.

Los componentes que interactúan entre sí durante el refuerzo son los siguientes:

• Environment
• Agent
• Task
• Experiment

El diseño del aprendizaje por refuerzo se da a continuación:

En RL, el agente habla con el entorno en iteración. En cada iteración, el agente recibe una observación que tiene la recompensa. Luego elige la acción y la envía al medio ambiente. El entorno en cada iteración se mueve a un nuevo estado y la recompensa recibida cada vez se guarda.

El objetivo del agente de RL es recolectar tantas recompensas como sea posible. Entre la iteración, el desempeño del agente se compara con el del agente que actúa de manera correcta y la diferencia en el desempeño da lugar a una recompensa o un fracaso. RL se utiliza básicamente en tareas de resolución de problemas como control de robots, ascensores, telecomunicaciones, juegos, etc.

Echemos un vistazo a cómo trabajar con RL en Pybrain.

Vamos a trabajar en un laberinto environmentque se representará utilizando una matriz numérica bidimensional donde 1 es una pared y 0 es un campo libre. La responsabilidad del agente es moverse por el campo libre y encontrar el punto de gol.

Aquí hay un flujo paso a paso de trabajar con el entorno de laberinto.

Paso 1

Importe los paquetes que necesitamos con el siguiente código:

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

Paso 2

Cree el entorno de laberinto usando el siguiente código:

# 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

Paso 3

El siguiente paso es crear Agent.

El agente juega un papel importante en RL. Interactuará con el entorno del laberinto utilizando los métodos getAction () e integrationObservation ().

El agente tiene un controlador (que asignará los estados a las acciones) y un alumno.

El controlador en PyBrain es como un módulo, para el cual la entrada es estados y los convierte en acciones.

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

los ActionValueTablenecesita 2 entradas, es decir, el número de estados y acciones. El entorno de laberinto estándar tiene 4 acciones: norte, sur, este, oeste.

Ahora crearemos un alumno. Vamos a utilizar el algoritmo de aprendizaje SARSA () para que el alumno lo utilice con el agente.

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

Etapa 4

Este paso consiste en agregar Agente al entorno.

Para conectar el agente al entorno, necesitamos un componente especial llamado tarea. El papel de untask es buscar el objetivo en el entorno y cómo el agente obtiene recompensas por sus acciones.

El medio ambiente tiene su propia tarea. El entorno Maze que hemos utilizado tiene la tarea MDPMazeTask. MDP significa“markov decision process”lo que significa que el agente conoce su posición en el laberinto. El entorno será un parámetro de la tarea.

task = MDPMazeTask(env)

Paso 5

El siguiente paso después de agregar el agente al entorno es crear un experimento.

Ahora tenemos que crear el experimento, para que la tarea y el agente se coordinen entre sí.

experiment = Experiment(task, agent)

Ahora vamos a ejecutar el experimento 1000 veces como se muestra a continuación:

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

El entorno se ejecutará 100 veces entre el agente y la tarea cuando se ejecute el siguiente código:

experiment.doInteractions(100)

Después de cada iteración, devuelve un nuevo estado a la tarea que decide qué información y recompensa se debe pasar al agente. Vamos a trazar una nueva tabla después de aprender y restablecer el agente dentro del ciclo 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")

Aquí está el código completo:

Ejemplo

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")

Salida

python maze.py

El color del campo libre cambiará en cada iteración.