You are here

Aula 6

Objetivos

Nesta aula, desenvolveremos as atividades dos tutoriais 7, 8 e 9 do Soar. No tutorial 7, veremos como funciona o mecanismo de Reiforcement Learning do Soar. No tutorial 8, veremos como funciona o mecanismo de memória semântica do Soar. No tutorial 9, veremos como funciona o mecanismo de memória episódica do Soar. Esses três mecanismos são desenvolvimentos mais recentes na arquitetura do Soar.

Atividade 1

Desenvolva as atividades do tutorial 7 do Soar. Registre as atividades desenvolvidas em seu relatório.

Atividade 2

Desenvolva as atividades do tutorial 8 do Soar. Registre as atividades desenvolvidas em seu relatório.

Atividade 3

Desenvolva as atividades do tutorial 9 do Soar. Registre as atividades desenvolvidas em seu relatório.

Durante a aula foram implementados e executados os tutoriais 7, 8 e 9 do Soar.

Foi possível aprender os diversos conceitos de aprendizado, como no primeiro caso, o Reinforcement Learning.

Diferentemente de chunking, que avalia o resultado e cria regras que removem as proposições que levam a falha, o reiforcement learning altera o "peso" de cada operador (preferencia numérica) durante a execução, dinamicamente.

Inicialmente foi visto um exemplo bem simple. O agente left-right consiste na escolha de mover para a direita ou esquerda e, baseado na decisão tomada, uma recompensa é dada ao agente (-1 para decisão ruim e +1 para decisão boa).

Um exemplo mais complexo do Reinforcement Learning pode ser aplicado no exemplo do Water-jug. Temos o caso abaixo de execução do Water-jug com RL habilitado. As próximas 3 figuras exibem o resultado das execuções de 1 a 4, onde podemos ver nas duas primeiras execuções, com a memória do Soar recém inicializada (sem as informações de aprendizado), que a solução é encontra depois de muitas execuções. Na terceira e quarta execução, podemos ver melhora notável na resolução dos problema, onde com poucas decisões a solução é encontrada, tendendo sempre para uma solução quase ótima (as vezes ótima).

Figura1 - Primeira execução, 32 decisões até a solução do problema

Figura2 - Segunda execução, 104 decisões até a solução do problema

Figura3 - Terceira e Quarta execução, 7 e 5 decisões respectivamente até a solução do problema.

Depois dessas execuções, é possível estudar a memória de aprendizado do Soar. Ao rodar o comando "print --rl", vemos os valores atribuidos a cada operador conforme Figura4 abaixo.

Figura4 - Imprimindo a memória de aprendizado do Soar

Podemos identifar por ai que os operadores com maior valor de indiferença são os operadores que levam a uma solução do problema, enquanto os valores com maior número de atualizações e menor valor, são os que distanciam mais a solução do problem.

Em detalhes, alguns operadores foram análisados e notamos que operadores básicos como encher o pote pequeno quando vazio e o grande estiver cheio, transferir o conteúdo do pote de pequeno para o grande quando o pote grande está vazio e transferir o conteúdo do pote de pequeno para o grande quando este tem 3 no conteúdo são os de maior valor. As regras de esvaziar tem os menores valores, visto que eles não são necessários para a solução do problema.

Figura5 - Detalhes dos operadores aprendidos

Como comparativo entre a aula anterior e essa, vemos que o Chunking é muito restritivo. Uma vez que a regra é aprendida e o chunking decidir por não executa-la, ela nunca mais é executada. Isso é notado no problema estudado da ultima aula onde o Soar nunca resolvia o problema (item 2.2 do tutorial 5) já no Reinforcement Learning não. Mesmo o peso de uma regra sendo menor que o outro, em algum momento ele pode ser escolhido, pois faz parte do mecanismo de decisão do Soar.

Outro ponto abordado na aula foi relacionado a memória (semantica e de episódio).

A memória semantica é utilizada para dados persistentes, não ligados diretamente ou indiretamente aos estados.

A forma de criação e manuseio desses elementos é explicita, ou seja, é necessário explicitar a criação, atualização e remoção desses elementos da memória.

O agente interage com a memória semântica por meio de uma estrutura (smem link) criada na memória de trabalho do SOAR. Essa estrutura possui dois atributos especiais, ^command utilizado para enviar comandos e ^result, utilizado para recuperar as informações da memória semântica do agente. O agente fica responsável elo atributo ^command enquanto o SOAR é responsável pelo ^result.

Para armazenar ou alterar os valores da memória semântica, são necessárias regras do agente para sua efetivação. O comando que deve ser considerado em ^command é o ^store. de tal forma no exemplo a seguinte regra é utilizada para iniciar o elemento da memória semântica.

sp {apply*init

(state <s> ^operator.name init
^smem.command <cmd>)
-->
(<s> ^name friends)
(<cmd> ^store <a> <b> <c>)
(<a> ^name alice ^friend <b>)
(<b> ^name bob ^friend <a>)
(<c> ^name charley)}
 
Quando essa regra é executada, podemos ver a execução do comando armazenando essas informações:
--- apply phase ---
--- Firing Productions (PE) For State At Depth 1 ---
Firing apply*init
-->
(C3 ^name charley + :O)
(B1 ^friend A1 + :O)
(B1 ^name bob + :O)
(A1 ^friend B1 + :O)
(A1 ^name alice + :O)
(C2 ^store C3 + :O)
(C2 ^store B1 + :O)
(C2 ^store A1 + :O)
(S1 ^name friends + :O)
--- Change Working Memory (PE) ---
=>WM: (25: C3 ^name charley)
=>WM: (24: B1 ^friend A1)
=>WM: (23: B1 ^name bob)
=>WM: (22: A1 ^friend B1)
=>WM: (21: A1 ^name alice)
=>WM: (20: C2 ^store A1)
=>WM: (19: C2 ^store B1)
=>WM: (18: C2 ^store C3)
=>WM: (17: S1 ^name friends)
--- Change Working Memory (PE) ---
=>WM: (28: R3 ^success @A1)
=>WM: (27: R3 ^success @B1)
=>WM: (26: R3 ^success @C3)

Para modificar o elemento, uma outra regra deve ser utilizada. Dessa forma devemos remover o comando de ^store anterior e alterar o valor anterior

 

sp {apply*mod
(state <s> ^operator.name mod
^smem.command <cmd>)
(<cmd> ^store <a> <b> <c>)
(<a> ^name alice)
(<b> ^name bob)
(<c> ^name charley)
-->
(<a> ^name alice -)
(<a> ^name anna
^friend <c>)
(<cmd> ^store <b> -)
(<cmd> ^store <c> -)}

 

O resultado da execução dessa regra acaba sendo da seguinte forma:

 

Firing apply*mod
-->
(C2 ^store @C3 - :O)
(C2 ^store @B1 - :O)
(@A1 ^friend @C3 + :O)
(@A1 ^name anna + :O)
(@A1 ^name alice - :O)
--- Change Working Memory (PE) ---
=>WM: (33: @A1 ^name anna)
=>WM: (32: @A1 ^friend @C3)
<=WM: (21: @A1 ^name alice)
<=WM: (18: C2 ^store @C3)
<=WM: (19: C2 ^store @B1)
--- Change Working Memory (PE) ---
<=WM: (26: R3 ^success @C3)
<=WM: (27: R3 ^success @B1)

 

Após algumas execuções, podemos ver um arquivo gerado no Soar exportando os valores da memória semantica do exemplo do tutorial 8 do pacote de tutoriais do Soar.

Figura6 - Memória Semantica exportada pelo Soar e visualizada pelo Graphviz

A recuperação desses elementos pode ser feita por duas maneiras: Non Cue Based e Cued Based.

A primeira delas é feita pelo comando ^retrieve passado em ^command. Ela trará todos os augumentos de um identificador long term conhecido. Já a segunda maneira é feito adicionando algumas augumentações de um identificador long term desconhecido como parametros. Nesse caso o comando a ser utilizado é o ^query.

Exemplo de regras para recuperação de memória na forma Non Cue Based:

 

sp {apply*ncb-retrieval*retrieve
(state <s> ^operator <op>
^smem.command <cmd>)
(<op> ^name ncb-retrieval
^friend <f>)
(<cmd> ^store <a>)
-->
(<cmd> ^store <a> -
^retrieve <f>)
Essas regras recuperam as informações de todos os amigos de Anna e escolhe uma das opçoes aleatoriamente
 
Exemplo de regras para recuperação de memória na forma Cue Based:
sp {apply*cb-retrieval
(state <s> ^operator <op>
^smem.command <cmd>)
(<op> ^name cb-retrieval)
(<cmd> ^retrieve <lti>)
-->
(<cmd> ^retrieve <lti> -
^query <cue>)
(<cue> ^name <any-name>
^friend <lti>)}
Essa regra recupera as informações de um identificador que satisfaça as condições de ter ^name e ^friend, nesse caso Anna. Caso as condições não sejam satisfeitas, o resultado seria Falha (em ^result)

 

Em outro tópico, foi estudado o elemento de memória de episódio. Essa configuração permite com que snaptshot da memória sejam criados baseados em configurações pré definidas (como por exemplo qual em qual fase será gravada, ou que ação disparará essa gravação).Esse mecanismo é utilizado para gravar dados historicos (autobiográficos da execução).

Similarmente ao smem, a memória episódica tem um uma estrutura específica epmem link. Similarmente ao smem, o epmem também contém os atributos ^command e ^result, com comportamento similar. Um terceiro atributo ^present-id é utilizado para identificar o momento da geração do snaptshop, atualizando para indicar o id do episódio corrente.

A forma de recuperar os dados da memória é muito similar ao Cue Based no mecanismo de memória semantica. o comando ^query é utilizado juntamente com os elementos utilizados pelo agente para buscar o elemento da memória. De tal forma é recuperada a memória de episódio associado aos elementos fornecidos nesse comando. O mecanismo de busca irá pontuar os episódios que seguem os critérios de busca e o resultado com maior pontuação e mais recente é retornado.

Uma outra forma de recuperar os dados da memória é por busca na progressão temporal, onde a partir de um identificador de memoria de episódio conhecido, podemos recuperar os episódios anteriores e posteriores com os comandos ^previous e ^next, respectivamente.

Exemplo de regra para recuperação Cue Based do tutorial:

 

sp {epmem*apply*cbr-query
(state <s> ^operator <op>
^epmem.command <cmd>)
(<op> ^name cbr)
-->
(<cmd> ^query <n1>)
(<n1> ^feature value
^id <n2>)
(<n2> ^sub-feature value2
^sub-id <n3>)}

 

Exemplo de regra para recuperação de maneira temporal do tutorial:

 

sp {epmem*apply*next
(state <s> ^operator <op>
^epmem.command <cmd>)
(<op> ^name next)
(<cmd> ^query <q>)
-->
(<cmd> ^query <q> -
^next <next>)}
 
sp {epmem*apply*previous
(state <s> ^operator <op>
^epmem.command <cmd>)
(<op> ^name previous)
(<cmd> ^query <q>)
-->
(<cmd> ^query <q> -
^previous<previous>)}

 

Um arquivo gerado no Soar exportando essas informações conforme executado no exemplo do tutorial 9 pode ser encontrado aqui.

Figura7 - Memória de Episódio exportada pelo Soar e visualizada pelo Graphviz

 

Referências:

  • Soar Tutorial 7, 8 e 9 do pacote de documentação do Tutorial Soar
  • Códigos de exemplos water-jug-rl, epmen-tutorial e smem-tutorial do pacote de agentes do Tutorial Soar
  • http://www.graphviz.org

 

Theme by Danetsoft and Danang Probo Sayekti inspired by Maksimer