PyBrain - Módulo de Aprendizagem por Reforço

Aprendizado por Reforço (RL) é uma parte importante do Aprendizado de Máquina. O aprendizado por reforço faz com que o agente aprenda seu comportamento com base nas informações do ambiente.

Os componentes que interagem uns com os outros durante o reforço são os seguintes -

Environment
Agent
Task
Experiment

O layout do Aprendizado por Reforço é fornecido abaixo -

Na RL, o agente conversa com o ambiente em iteração. A cada iteração, o agente recebe uma observação que tem a recompensa. Em seguida, ele escolhe a ação e envia para o ambiente. O ambiente em cada iteração muda para um novo estado e a recompensa recebida cada vez é salva.

O objetivo do agente RL é coletar o máximo de recompensas possível. No intervalo entre as iterações, o desempenho do agente é comparado com o do agente que age de maneira positiva e a diferença no desempenho dá origem a recompensa ou fracasso. RL é basicamente usado em tarefas de resolução de problemas como controle de robô, elevador, telecomunicações, jogos, etc.

Vamos dar uma olhada em como trabalhar com RL em Pybrain.

Vamos trabalhar no labirinto environmentque será representado usando matriz numpy 2 dimensional, onde 1 é uma parede e 0 é um campo livre. A responsabilidade do agente é mover-se sobre o campo livre e encontrar o ponto de gol.

Aqui está um fluxo passo a passo do trabalho com o ambiente de labirinto.

Passo 1

Importe os pacotes de que precisamos com o código abaixo -

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

Crie o ambiente de labirinto usando o código abaixo -

# 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

etapa 3

A próxima etapa é criar o Agente.

O agente desempenha um papel importante na RL. Ele irá interagir com o ambiente de labirinto usando os métodos getAction () e integrateObservation ().

O agente tem um controlador (que mapeia os estados para ações) e um aluno.

O controlador no PyBrain é como um módulo, para o qual a entrada é estados e os converte em ações.

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

o ActionValueTableprecisa de 2 entradas, ou seja, o número de estados e ações. O ambiente de labirinto padrão tem 4 ações: norte, sul, leste, oeste.

Agora vamos criar um aluno. Usaremos o algoritmo de aprendizado SARSA () para o aluno a ser usado com o agente.

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

Passo 4

Esta etapa é adicionar agente ao ambiente.

Para conectar o agente ao ambiente, precisamos de um componente especial chamado tarefa. O papel de umtask é procurar a meta no ambiente e como o agente obtém recompensas pelas ações.

O meio ambiente tem sua própria tarefa. O ambiente Maze que usamos tem a tarefa MDPMazeTask. MDP significa“markov decision process”o que significa que o agente conhece sua posição no labirinto. O ambiente será um parâmetro para a tarefa.

task = MDPMazeTask(env)

Etapa 5

A próxima etapa após adicionar o agente ao ambiente é criar um Experimento.

Agora precisamos criar o experimento, para que possamos ter a tarefa e o agente coordenados um com o outro.

experiment = Experiment(task, agent)

Agora vamos executar o experimento 1000 vezes, conforme mostrado abaixo -

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

O ambiente será executado 100 vezes entre o agente e a tarefa quando o seguinte código for executado -

experiment.doInteractions(100)

Após cada iteração, ele retorna um novo estado para a tarefa que decide quais informações e recompensas devem ser repassadas ao agente. Vamos plotar uma nova tabela depois de aprender e redefinir o agente dentro do loop 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")

Aqui está o código completo -

Exemplo

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

Resultado

python maze.py

A cor no campo livre será alterada a cada iteração.

↰ Previous page Next page ↱