Upload
internet
View
103
Download
1
Embed Size (px)
Citation preview
Linguagens de Programação para SMA
Viviane Torres da [email protected]
http://www.ic.uff.br/~viviane.silva/isma
Algumas linguagens de programação
Agent0
Placa
AgentSpeak
Metatem
A idéia de uma linguagem de programação para SMA
1993: Yoav Shoham propôs a criação de um novo paradigma de programação baseado nos aspectos sociais da computação
Programação orientada a agentes: os agentes são as entidades da linguagem de programação
Programar os agentes em termos de seus estados mentais – Crenças, desejos (ou objetivos) e intenções (ou planos)
Primeira linguagem de programação: Agent0
Agent0
Um agente tem:– Um conjunto de capacidades– Um conjunto de crenças– Um conjunto de compromissos– Um conjunto de regras de compromissos
São as regras que determinam se o agente executará uma ação
Cada regra de compromisso contém:– Uma condição de mensagem que deve ser comparada com as
mensagens recebidas pelo agente– Uma condição do estado mental que deve ser comparada com as
crenças do agente– Uma ação que o agente terá o compromisso de executar se as condições
forem satisfeitas
Agent0
As ações podem ser:– Privadas: ações internas do agente
– De comunicação: enviar mensagens
Uma mensagem pode ser de 3 tipos:– Requests: um pedido para fazer uma ação
– Unresquests: uma negociação para fazer uma ação
– Inform: um envio de uma informação
Agent0 é uma extensão Lisp
Exemplo: Regra de compromisso
COMMIT(( agent, REQUEST, DO(time, action)),;;; msg condition
( B,[now, Friend agent] ANDCAN(self, action) ANDNOT [time, CMT(self, anyaction)]
), ;;; mental condition
self,DO(time, action) )
Se o agente recebe uma mensagem de outro agente pedindo para executar uma ação em um determinado momento
Se o agente crê que o outro agente é um amigo eo agente sabe executar a ação e
no momento não está executando nenhuma
ação
então o agente cria o compromisso de executar a ação
Agent0
É possível implementar a comunicação e a cooperação entre os agentes
Mas, ainda é um protótipo de linguagem de programação para ilustrar alguns conceitos
A linguagem PLACA estende a linguagem Agent0: – Possibilita o agente criar planos
Placa
(((self ?agent REQUEST (?t (xeroxed ?x)))
(AND (CAN-ACHIEVE (?t xeroxed ?x)))
(NOT (BEL (*now* (vip ?agent))))
((ADOPT (INTEND (5pm (xeroxed ?x)))))
((?agent self INFORM (*now* (INTEND (5pm (xeroxed ?x)))))))
Se um agente te pede para fazer cópias
Se você sabe fazer
Se não é um agente VIP
Adota a intenção de fazer as cópias às 5pm(adoção do plano)
Informa ao agente que tem a intenção de fazer as cópias
AgentSpeak(L)
Linguagem baseada em eventos e ações
O comportamento do agente é implementado com a linguagem
As crenças, os objetivos (ou desejos) e os planos (ou intenções) podem ser descritos em AgentSpeak
– Crenças: estado do agente, do ambiente e de outros agentes– Objetivos: estado que o agente quer alcança ou verificar– Planos: programa para alcançar os objetivos
Um programa em AgentSpeak consiste de um conjunto de crenças e um conjunto de planos
AgentSpeak(L)
Exemplo:– Existem faixas por onde podem estar os carros
– As faixas podem ter lixo
– Robôs têm a obrigação de pegar o lixo e colocar em lixeiras
– Robôs podem mover-se de uma faixa para a outra
Crenças: Crenças atômicas: “classes” para criar instancias
– Localização (robô, faixa), localização (carro, faixa), adjacente (faixa, faixa)
Crenças básicas: instâncias das classes– adjacente (a, b), localização (robôA, a)
AgentSpeak(L)
Objetivo: Objetivo para ser alcançado: !g(t)
– Agente quer alcançar um estado onde g(t) é verdade– !limpo (b) : agente quer que a faixa b esteja limpa
Objetivo para ser testado: ?g(t)– Agente quer verificar se g(t) é uma crença verdadeira– ?localização (carro, b) : agente pergunta se existe algum carro na faixa b
Novos objetivos e novas crenças podem ser criados e objetivos e crenças podem ser apagados.
– +localização (lixo, a) : criação da crenças que diz que existe lixo na faixa a
– +!limpo (a) : criação do objetivo para limpar a faixa a
AgentSpeak(L)
Plano Tem uma cabeça e um corpo Cabeça consiste de:
– Eventos de ativação do plano: criação ou destruição de crenças e objetivos.
– Contexto: as crenças que devem ser verdadeiras para executar o plano.
Corpo consiste de:– Seqüência de ações e objetivos.
+localização (lixo, X):
localização (robô, X) & localização (lixeira, Y)<-recolher (lixo);
!localização (robô, Y);
jogar (lixo,lixeira).
eventos de ativação
contexto
corpo
Crença foi criada (existe lixo em X)
Objetivo a ser alcançado
AgentSpeak(L)
+!localização (robô, Y):
localização (robô, Y) <- verdade
+!localização (robô, Y):
localização (robô, X) &
(não (X = Y)) &
adjacente (X, Z) &
(não (localização (carro, Z)))
<- mover (X, Z);
+!localização (robô, Y).
Objetivo criado
Execução de um programa em AgentSpeak(L)
Se existem mais eventos para serem processados, selecionar um (Se).
Retirar da biblioteca de planos todos os planos ativados pelo evento e que podem ser executados com as circunstancias atuais.
Selecionar um plano (S0), criando uma intenção de execução
Executar o plano, selecionando a primeira intenção (Si). Se encontrar uma ação, executar a ação, se encontrar um objetivo incluir na lista de eventos que serão processados.
METATEM
É uma linguagem para implementação de sistemas multi-agentes que utiliza lógica temporal para especificar o comportamentos dos agentes
Lógica temporal é uma lógica clássica com operadores modais para descrever como a verdade sobre as proposições podem variar no tempo
As especificações são executadas para gerar o comportamento dos agentes
METATEM
importante (agentes)– É verdade agora e sempre será que os agentes são importantes
importante (Metatem)– Em algum momento no futuro Metatem será importante
importante (Prolog)– Em algum momento no passado, Prolog foi importante
( amigos (eu, você)) S brigar (eu, você)– Não somos amigos desde o dia que brigamos
( amigos (eu, você)) U desculpar-se (você)– Não somos amigos até que você se desculpe (em algum momento no futuro)
desculpar-se (você)– Amanha (no próximo estado) você se desculpará
Significa até que (until)
Significa desde que (since)
METATEM
Um programa em Metatem é um conjunto de regras Executando regras:
Passado Futuro
Se verifica se os fatos do passado são verdades Se o passado de uma regra é verdade, “ativa-se” os fatos do
futuro
trem (E, T) ^ semáforo (vermelho) trem (E, T)
trem (E, T) ^ semáforo (verde) ^ mover (T,E,S) trem (S, T)
noivos (Ana, João) casados (Ana, João)
Componentes de um objeto
Definição da interface: – define quais mensagens o objeto reconhece (recebe) e quais produz
(envia)
– mensagens que reconhece: colocarElemento e tirarElemento
– mensagens que produz: pilhaCheira e elementoPosto
Definição interna: – o conjunto de regras do objeto
Ex:pilha (colocarElemento, tirarElemento) [pilhaCheia, elementoPosto]
Exemplo: Trens e Estações
Interfaces:
estação (mover, permissão)[moveu]– mover (E, T) : mensagem que pede a permissão para o trem T mover-se para a
estação E
– permissão (E, T) : mensagem que permite que o trem T se mova para a estação E
– moveu (E, T) : mensagem que informa que o trem T se moveu para a estação E
– tem (E,T): mensagem que informa que o trem T está na estação E
– linha (L, T) : mensagem que informa que a linha L tem o trem T
– próxima (E, L, F): msg que informa que a estação adjacente a E é F na linha L.
Regras:
1. Se a estação tem o trem e o trem não se moveu, o trem segue na estação tem (E,T) ^ ¬ moveu (F, T) tem (E,T)
Exemplo: Trens e Estações
Regras:
2. Se um trem acaba de mover-se para uma estação, a estação tem o tremmoveu (E,T) tem (E,T)
3. Se uma estação tem um trem e acaba de receber a permissão de mover o trem para a próxima estação, o trem estará na próxima estação no futurotem (E,T) ^ permissão (F, T) ^ línea (L,T) ^ próxima (E, L, F)
moveu (F,T)
4. Se um trem acaba de mover-se para uma estação, a estação não pode dar a permissão para nenhum trem mover-se para a estaçãomoveu (E, T) ¬ permissão (E, T’)
METATEM Concorrente
Existem vários objetos enviando mensagens, recebendo mensagens e executando assincronamente
A execução de um objeto não está orientada à mensagens. Sua execução é independente das mensagens que recebe e que envia.
Um objeto pode modificar sua interface dinamicamente, isso é, as mensagens que reconhece e como as manipula