Atividade Aula 2

Atividade 1)

  O SOAR foi devidamente obtido do link http://soar.eecs.umich.edu/articles/downloads/soar-suite/103-soar-suite-9-4-0 e instalado no computador. Foi também feito o download do tutorial na página indicada nas instruções da aula 2.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Atividade 2)

  Criando um Agente SOAR e Utilizando o SOAR Debugger

    Foi executado o programa SoarJavaDebugger.sh e foram observadas as funções das janelas da IDE. A figura a seguir foi extraída do pdf do Tutorial 1.

  Executando o Hello World do SOAR

    Seguindo as instruções do Tutorial 1, foi carregado e executado o arquivo source hello-world-rule.soar.

    Foi visto aqui que as regras do SOAR possuem uma estrutura do tipo if-then. A figura abaixo exemplifica uma regra do SOAR e foi extraída do Tutorial 1.

  Utilizando a Memória de Trabalho

    A Working Memory do SOAR se organiza na forma de um grafo e, como tal, possui nós (vértices) e links (arestas).

    Existem dois tipos de nós: os identificadores (que são identificados por nomes compostos por uma letra e um número e que podem ter links emanando a partir deles) e as constantes (que são nós terminais, sem links).

    Os links são chamados de atributos no SOAR e são precedidos pelo símbolo ^.

    As informações na Working Memory são constituídas de elementos compostos por um identificador, um atributo e um valor, sendo que o valor pode ser tanto uma constante (nó terminal) ou um identificador (um nó identificador).

    O conjunto de elementos da Working Memory que compartilham o mesmo primeiro identificador são chamados de objeto e, cada um destes elementos é chamado de aumento. Exemplos de objeto podem ser vistos abaixo (exemplos extraídos do pdf do Tutorial 1):

  Exemplo 1)

                (S1 ^io I1 ^superstate nil ^type state)

  Exemplo 2)

    Uma vez que o nome do identificador é gerado automaticamente pelo SOAR, não é possível realizar um acesso ao nó identificador através de um valor específico. Para realizar o acesso ao identificador, utiliza-se então as variáveis. A variável dá match em qualquer símbolo no Working Memory, desde que todas as ocorrências da mesma variável se refiram sempre ao mesmo símbolo. Uma variável pode dar match tanto em identificador, atributo e valor, dependendo da posição em uma condição. Variáveis sempre vêm entre os símbolos <>.

    No SOAR, toda regra deve iniciar pelo match de uma estrutura com um estado, assim a primeira condição de qualquer regra deve se iniciar com a palavra state.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Atividade 3)

  Executando o Hello World com Operadores

    Regras com operadores provavelmente tornam o código mais organizado por separar a estrutura de decisão e a execução das ações. Assim, as regras propõem operadores e, caso sejam disparadas, os operadores executam as ações atreladas a eles.

    Seguindo o tutorial 1, foi realizado o upload do programa hello-world-operator.soar.

  Foi também selecionada a opção watch 5, que permite uma melhor visualização do processo, auxiliando o processo de debug, caso seja necessário. Assim, detalhes do funcionamento do programa podem ser vistos ao clicar nos botões + e - ao lado esquerdo da Working Memory.

  Examinando a Memória de Trabalho

    A proposta de operador (propose*hello-world), como uma regra comum, contém uma condição e as ações. A condição do operador Hello_world seria a existencia de um estado (identificador) referido pela variável <s> e que contém ligação (^type) a um nó (atributo) estado. Satisfeita a condição, o operador executa as seguintes ações: 1) cria um nó (identificador) de operador <o> no grafo, ligado ao nós <s> por um link do tipo ^operador, e o indica como uma preferência aceitável (o operador é um candidato para seleção); 2) cria um nó contendo o nome (hello_world) ligado ao nó de operador.

    A regra de aplicação (apply*hello_world) tem duas condições: 1) a existência de um nó de operador <o> ligado a um nó (identificador) de estado <s> por um link ^operador; 2) a existência de um nó contendo o nome (hello_world), ligado ao nó de operador <o> por meio de um link ^nome.

    A partir do programa SoarDebugger, com o auxilio do botão Watch 5 e do botão Run 1-p, foi possível observar que as regras funcionam por etapas que se sucedem na sequencia:

  - input phase: trata-se da etapa em que o SOAR recebe entradas externas.

  - propose phase: etapa em que o SOAR recebe as propostas de operador.

  - decision phase: etapa em que o SOAR decide qual operador executar.

  - apply phase: etapa de execução da ação atrelada ao operador escolhido.

  - output phase: etapa em que o SOAR retorna saídas para o ambiente externo.

    Uma vez executado o programa, ao digitar o comando print s1, obtém-se a seguinte resposta:

    (S1 ^epmem E1 ^io I1 ^operator O1 ^operator O1 + ^reward-link R1 ^smem S2 ^superstate nil ^svs S3 ^type state)

    Este resultado descreve a situação do grafo do estado s1 do working memory.

    Os operadores que podem ser aplicados neste estado são indicados pelo sinal + junto do atributo operator. O operador selecionado no estado é o que aparece escrito sem o sinal +. É interessante também observar o atributo io (I1).

    Ao digitar o comando print I1, obtém-se a seguinte resposta:

    (I1 ^input-link I2 ^output-link I3)

    Este resultado indica que o input e o output de sinais externos do agente são feitos respectivamente pelos atributos input-link I2 e output-link I3.

  Utilizando o VisualSoar

    Segundo o texto do Tutorial 1, apesar de ser possível utilizar qualquer editor de texto para criar arquivos com as regras, o VisualSoar possui um suporte interno para isto.

    O VisualSoar permite a visualização da estrutura do programa na forma de uma arvore. Esta arvore irá conter e agrupar os arquivos com as regras. O agrupamento das regras no VisualSoar é arbitrário ao Soar, impedindo que o programador cometa erros ao agrupar as regras e facilitando a manutenção e debug do código.

    Uma vez que uma das maiores dificuldades ao se escrever um código Soar é a visualização do Working Memory como uma estrutura em forma de árvore, o VisualSoar também possui uma ferramenta chamada Datamap, que mostra a estrutura hierárquica do Working Memory do agente.

    Além de possibilitar a visualização da memória, o VisualSoar também permite a execução de testes para verificação do código em busca de erros de digitação, posicionamento de estruturas, etc.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Atividade 4)

    O water jug problem consiste na seguinte situação: dispõe-se de dois jarros de agua não graduados, um com capacidade para 5 galões e o outro com capacidade para 3 galões. Pode-se encher totalmente e esvaziar totalmente os jarros quantas vezes for necessário. Pode-se também transferir o conteúdo de um jarro para o outro. O objetivo do problema é encher o jarro de menor com apenas 1 galão.

    Segundo o tutorial 1, a solução do problema consiste em começar por um estado inicial (com os dois jarros vazios) e procurar por um estado desejado (qualquer estado onde o jarro menor possua apenas 1 galão). Esta busca é feita por meio da aplicação de operadores, que transformam um estado em outro. Para o problema em questão, os operadores devem ser 'encher um jarro', 'esvaziar um jarro' e 'transferir o conteúdo de um jarro para o outro'.

  Persistência de WMEs

    Para gerenciar a persistencia dos WME's, o Soar faz uma distinção entre os elementos de memória gerados automaticamente e os elementos de memória gerados explicitamente por Operadores. Quando a regra que aplicou o operador deixa de valer (as condições do if não são mais satisfeitas), o operador também deixa de existir, mas os elementos de Working Memory criados pelos operadores não são apagados até que outro operador o faça. Já os elementos de Working Memory criados automaticamente pelo programa para a realização de processamento durante um estado são apagados após o uso neste estado.

  Elaboração de Estado

    A elaboração de estado é uma ferramenta de simplificação para a criação de elementos de memória. No caso do exemplo Water Jug, o elemento a ser criado seria o valor do espaço vazio disponível em cada jarro. Pode-se fazer a criação deste elemento por meio de um operador, mas isto seria trabalhoso pois deveria ser atualizado a cada mudança de estados. Em vez disso, pode-se utilizar uma regra de elaboração de estados, que observa os valores de espaço total e espaço cheio dos jarros, calcula o espaço vazio e cria os elementos com este atributo. Assim, as regras de elaboração de estado são aquelas que servem para a geração automática de elementos de memória de trabalho, em função de elementos já existentes no objeto.

  Proposição de Operadores

    S3.

  Aplicação de Operadores

    S3.

  Monitoramento de Estados e Operadores

    S3.

  Reconhecimento do Estado Desejado

    S3.

  Controle de Busca

    S3.

  Conclusão

    S3.