PyBrain - Modulo di apprendimento per rinforzo

Il Reinforcement Learning (RL) è una parte importante nell'apprendimento automatico. L'apprendimento per rinforzo fa sì che l'agente apprenda il proprio comportamento in base agli input dall'ambiente.

I componenti che interagiscono tra loro durante il rinforzo sono i seguenti:

• Environment
• Agent
• Task
• Experiment

La struttura del Reinforcement Learning è fornita di seguito:

In RL, l'agente dialoga con l'ambiente in iterazione. Ad ogni iterazione, l'agente riceve un'osservazione che ha la ricompensa. Quindi sceglie l'azione e invia all'ambiente. L'ambiente ad ogni iterazione si sposta in un nuovo stato e la ricompensa ricevuta ogni volta viene salvata.

L'obiettivo dell'agente RL è raccogliere il maggior numero di ricompense possibile. Tra l'iterazione, la prestazione dell'agente viene confrontata con quella dell'agente che agisce in modo positivo e la differenza di prestazioni dà luogo a ricompensa o fallimento. RL è fondamentalmente utilizzato in attività di problem solving come controllo di robot, ascensore, telecomunicazioni, giochi, ecc.

Diamo un'occhiata a come lavorare con RL in Pybrain.

Lavoreremo su Maze environmentche sarà rappresentato utilizzando un array numpy bidimensionale dove 1 è un muro e 0 è un campo libero. La responsabilità dell'agente è di spostarsi sul campo libero e trovare il punto obiettivo.

Ecco un flusso passo passo per lavorare con l'ambiente labirinto.

Passo 1

Importa i pacchetti di cui abbiamo bisogno con il codice seguente:

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

Passo 2

Crea l'ambiente labirinto usando il codice seguente -

# 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

Passaggio 3

Il passaggio successivo consiste nel creare Agent.

L'agente gioca un ruolo importante in RL. Interagirà con l'ambiente labirinto usando i metodi getAction () e integrateObservation ().

L'agente ha un controller (che mapperà gli stati alle azioni) e uno studente.

Il controller in PyBrain è come un modulo, per il quale l'ingresso è stato e li converte in azioni.

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

Il ActionValueTablenecessita di 2 input, ovvero il numero di stati e azioni. L'ambiente standard del labirinto ha 4 azioni: nord, sud, est, ovest.

Ora creeremo uno studente. Useremo l'algoritmo di apprendimento SARSA () per lo studente da utilizzare con l'agente.

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

Passaggio 4

Questo passaggio è l'aggiunta dell'agente all'ambiente.

Per connettere l'agente all'ambiente, abbiamo bisogno di un componente speciale chiamato task. Il ruolo di atask è cercare l'obiettivo nell'ambiente e come l'agente ottiene ricompense per le azioni.

L'ambiente ha il suo compito. L'ambiente Maze che abbiamo utilizzato ha un'attività MDPMazeTask. MDP sta per“markov decision process”il che significa che l'agente conosce la sua posizione nel labirinto. L'ambiente sarà un parametro per l'attività.

task = MDPMazeTask(env)

Passaggio 5

Il passaggio successivo dopo l'aggiunta dell'agente all'ambiente consiste nel creare un esperimento.

Ora dobbiamo creare l'esperimento, in modo da avere il compito e l'agente di coordinarsi tra loro.

experiment = Experiment(task, agent)

Ora eseguiremo l'esperimento 1000 volte come mostrato di seguito:

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

L'ambiente verrà eseguito per 100 volte tra l'agente e l'attività quando viene eseguito il codice seguente:

experiment.doInteractions(100)

Dopo ogni iterazione, restituisce un nuovo stato all'attività che decide quali informazioni e ricompense dovrebbero essere passate all'agente. Tracciamo una nuova tabella dopo aver appreso e reimpostato l'agente all'interno 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")

Ecco il codice completo -

Esempio

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

Produzione

python maze.py

Il colore nel campo libero verrà cambiato ad ogni iterazione.