Implementando os SMA

Implementando os SMA

Viviane Torres da [email protected]

http://www.ic.uff.br/~viviane.silva/isma

Motivação

Motivação: Como implementar as entidades de um SMA (agentes, organizações, objetos, ....)?

– Não existe uma linguagem de programação para SMA que possibilite implementar todas as características dos agentes

Objetivo: propor frameworks e plataformas que se baseiem em linguagens de implementação já conhecidas

– Linguagens OO

Solução: frameworks e plataformas baseados em Java– ASF, Jade, Jadex, Jack, ASF, Jason, ....

Arquitetura BDI

Arquitetura abstrata para implementação de SMA

Arquitetura BDI

Modelo proposto por Bratman em 1987

Modelo consiste de:– Beliefs: crenças

– Desire: desejos ou objetivos

– Intetions: intenções ou planos

Arquitetura BDI proposta por Rao e Georgeff em 1995– É uma arquitetura abstrata

Arquitetura BDI

FIPA (Foundation for Inteligent Physical Agents)

ISMA Viviane Torres da Silva

FIPA

FIPA: propõe padrões para organizar os agentes e os sistemas multi-agente

FIPA: Agent Management

Agent Platform (AP): plataforma onde o agente executa– Estrutura física onde o agente se encontra

Service

FIPA: Agent Management

Directory Facilitator (DF): provê um serviço de páginas amarelas para os agentes.

– cada agente registra o serviço que oferece.

Agent Management System (AMS): controla o acesso e o uso da plataforma

– só existe um por plataforma

– todo agente de uma AP precisa se registrar no AMS

– contém uma lista de endereços dos agentes registrados na plataforma

– oferece serviço de páginas brancas para conhecer os agentes registrados

Message Transport Service (MTS): serviço de comunicação entre agentes de diferentes plataformas

FIPA: Agent Message Transport

Define as três possíveis formas de comunicação– ACC : Agent Communication Channel (liga com a buferização da

mensagem, o endereçamento, a transferência, os erros, ...)

FIPA: Agent Message Transport

Envelope: detalhes do transportePayload: mensagem ACL comprimida

JADE Java Agent Development Framework

http://jade.tilab.com/

http://jade.tilab.com/

JADE

Jade é um framework para o desenvolvimento de SMA

Atualmente na versão 4.3

Inclui:– Um ambiente de execução onde os agentes JADE "vivem" e que deve

estar ativo em um host antes que um agente possa ser executado

– Uma biblioteca de classes que programadores podem usar para desenvolver agentes

– Um conjunto de ferramentas gráficas que permite a administração e o monitoramento das atividades dos agentes em execução

Conceitos Importantes

JADE deve ser utilizado para …– implementar sistemas distribuídos

– agentes móveis

Contêiner– Instância de um ambiente Jade

– É onde os agentes executam

– Ao iniciar o Jade, um MainContainer é criado

Plataforma– Conjunto de contêineres ativos

Contêineres e Plataformas

Modelo FIPA

JADE segue o modelo de desenvolvimento da FIPA Todo MainContainer tem um AMS e um DF

Agent Management System (AMS)– Agente que exerce o controle sobre o acesso e o uso da plataforma

– Existe um único AMS por plataforma

– Mantém a lista de identificadores dos agentes (AID) que estão na plataforma

– Todo agente deve se registrar no AMS

Directory Facilitator (DF)– Oferece o serviço de páginas amarelas na plataforma

Classe Agent

Representa a classe base para a definição de agentes

Para o desenvolvedor, um agente Jade é uma instância de uma classe Java que estende a classe Agent

Já oferece todas as interações básicas da plataforma (registro, configuração, etc...)

Oferece um conjunto de métodos para a implementação do comportamento do agente

Modelo Computacional do Agente

Um agente é multi-tarefa, onde os serviços são executados concorrentemente

Cada serviço de um agente deve ser implementado como um ou mais comportamentos

A classe Agent oferece um scheduler (não acessível ao programador) que gerencia automaticamente o agendamento dos comportamentos

O Ciclo de Vida de um Agente I/III

O Ciclo de Vida de um Agente II/III

Iniciado– O objeto agente é criado, mas ainda não se registrou no AMS, i.e. não

possui um identificador e não pode se comunicar com outros agentes

Ativo– O objeto agente está registrado no AMS, possui um identificador e pode

executar seus serviços

Suspenso– O objeto agente está parado, i.e. sua thread interna está suspensa e o

agente não está executando serviço algum

O Ciclo de Vida de um Agente III/III

Esperando– O agente está bloqueado, esperando por algum evento, i.e. sua thread

interna está dormindo e será acordada quando uma condição se tornar verdadeira

Removido– O agente terminou sua execução, i.e. sua thread interna acabou sua

execução e o agente não está mais registrado no AMS

Em Trânsito– Um agente móvel entra neste estado quando está migrando para um novo

local (contêiner). O sistema continua a armazenar as mensagens enviadas a este agente, que lhe serão passadas quando ele estiver no novo local

Criando um agente Jade

Jade gerencia a criação de um novo agente com os seguintes passos

O construtor do agente é executado– O agente recebe um identificador do AMS

– Ex: agente@localhost:1099/JADE• nomeAgente @ nomePlataforma : numeroPorta / JADE

– Entra no estado Ativo

É executado o método setup()– Método responsável por inicializar os comportamentos do agente

Destruindo um agente Jade

Mesmo que não esteja fazendo coisa alguma, o agente continua ativo

Para terminar um agente, deve-se executar o método doDelete() que chama o método takeDown() (pode ser reimplementado)

– Serve para remover todas as referências ao agente da plataforma

Classe Behaviour

Todas as tarefas dos agentes são executadas por meio de "comportamentos"

Um comportamento é um objeto da classe Behaviour

O agente adiciona um comportamento com o método addBehaviour(X)

Comportamentos podem ser adicionados a qualquer momento com o método removeBehavior(X)

Classe Behaviour

Método action()– Método que define as operações que são executadas quando o

comportamento está em execução

Método done()– Método que especifica se um comportamento foi completado e deve ser

removido do pool de comportamentos que um agente está executando

Hierarquia de comportamentos I/II

Comportamentos Simples– Modelam os comportamentos atômicos

– OneShotBehaviour: modela comportamentos que só devem executar uma vez e que não podem ser bloqueados (parar o comportamento até que algum evento ocorra)

– CyclicBehaviour: Modela comportamentos atômicos que devem ser executados eternamente

Comportamentos Compostos– Modelam comportamentos que são compostos de outros comportamentos.

– As operações que devem ser executadas não estão definidas neste comportamento em si, mas nos comportamentos filhos que o compõem

– SequentialBehaviour, ParallelBehaviour e FSMBehaviour

Hierarquia de comportamentos II/II

Comportamentos compostos– SequentialBehaviour: Executa seus sub-comportamentos

seqüencialmente e termina quando todos estes estiverem terminados

– ParallelBehaviour: Executa seus sub-comportamentos concorrentemente e termina quando uma condição particular sobre o conjunto de sub-comportamentos é alcançada

– FSMBehaviour: Executa seus sub-comportamentos como uma Máquina de Estados Finita (FSM). Quando uma tarefa acaba, sua saída é usada para se calcular a transição para a próxima tarefa. O comportamento termina quando uma tarefa final é executada

Comportamentos Especiais

WakerBehaviour– Comportamento que espera um determinado período de tempo (em ms)

para efetivamente executar a tarefa

TickerBehaviour– Comportamento que executa uma tarefa periodicamente em intervalos

de tempo constantes (em ms). Este comportamento nunca acaba

Comunicação entre os agentes I/III

A comunicação é assíncrona e utiliza FIPA ACL

Os objetos enviados são instâncias de ACLMessage

Para enviar uma mensagem se chama o método send()

ASF Framework

Agent Society Framework

ASF: Agent Society Framework

Objetivo: dar suporte a implementação de agentes, organizações, papéis e ambiente

Como implementar ...– as entidades,

– suas propriedades,

– seus relacionamentos,

– a interação entre as entidades e

– a execução interna das entidades

Framework OO

É orientado a um domínio de aplicações– Captura os conceitos gerais de um domínio

Define um conjunto de classes relacionadas capazes de gerar diferentes aplicações em um mesmo domínio

Classes são reutilizadas ou estendidas para implementar uma determinada aplicação

– Define partes que são fixas, i.e., não podem ser estendidas

– Define partes que são flexíveis, i.e, podem ser estendidas

Entidades

Objetos– Atributos e métodos

Agentes– Objetivos, crenças, planos e ações

Organizações– Objetivos, crenças, planos, ações e axiomas

Papel de agente– Objetivo, crença, deveres, direitos e protocolos

Papel de objetos– Atributos e métodos

Ambiente– Atributos e métodos

Aspectos Estruturais do ASF

Fornece um conjunto de módulos que devem ser estendidos para implementar a aplicação

Cada módulo representa uma entidade do SMA

Instanciação da aplicação:– para implementar uma classe de agente da aplicação estende-se o

módulo Agent– para implementar uma classe de organização da aplicação estende-se o

módulo Organization– ...

Agente

Classe Agente– Thread (entidade autônoma)

Classe Mensagem– Enviadas e recebidas

Classe Objetivo– Nome, tipo, valor

– Está associado a planos que podem ser alcançar o objetivo

Classe Crença– Nome, tipo, valor

Agente

Classe Plano– Define uma ordem de execução de um conjunto de ações

– Está relacionado a goals que pode atingir

Classe Ação– Define a execução interna do agentes (entidade adaptativa)

– Possui pré e pós-condições

Tem que existir ao menos uma instância de agente

Módulo Agent

Organização

Organização– Thread (entidade autônoma)

Classe Main-organization– Não desempenha papéis– Pode definir sub-organizações

Classe (Sub-)Organization– Desempenha papéis em organizações– Pode definir sub-organizações

Goals, beliefs, plans, actions and messages Axiom:

– Nome, tipo, valor

Tem que existir ao menos uma instância da organização principal

Módulo Organization

Role de Agente

Classes Goals, Beliefs

Classe Duty– Define ações que são obrigações

Classe Right– Define ações que são direitos

Classe Protocol– Define ordem de envio e recebimento de mensagens

Tem que existir ao menos uma instância desempenhada por um agente

Módulo Agent Role

Módulo Object Role

Atributos Métodos

Módulo Environment

Tem que existir ao menos uma instância de ambiente donde estará a organización principal e os agentes

Relação entre as entidades


Estrutura do ASF

Exemplo

Jason

Com base nas transparências de Rafael Bordini


Jason

Jason implements the operational semantics of a variant of AgentSpeak

Has various extensions aimed at a more practical programming language (e.g. definition of the MAS, communication, ...)

Highly customized to simplify extension and experimentation

Developed by Jomi F. Huner and Rafael H. Bordini


Main Language Constructs and Runtime Structures

Beliefs: represent the information available to an agent (e.g.

about the environment or other agents) Goals: represent states of affairs the agent wants to bring about Plans: are recipes for action, representing the agent's know-

how

Events: happen as consequence to changes in the agent's beliefs or goals

Intentions: plans instantiated to achieve some goal


Main Architectural Components

Belief base: where beliefs are stored

Set of events: to keep track of events the agent will have to handle

Plan library: stores all the plans currently known by the agent

Set of Intentions: each intention keeps track of the goals the agent is committed to and the courses of action it chose in order to achieve the goals for one of various foci of attention the agent might have


Jason Interpreter: Bacis Reasoning cycle

Perceive the environment and update belief base Process new messages Select event Select relevant plans (plans trigerred by the event) Select applicable plans (plans which condictions are true) Create/update intention Select intention to execute


Jason Reasoning Cycle


Beliefs

Beliefs are represented by annotated literals of rst order logic functor(term1, ..., termn)[annot1, ..., annotm]

Examples: red(box1) friend(bob,alice) lier(alice) ~lier(bob)[source(self)]

Adding beliefs: +lier(alice) .send(tom,tell,lier(alice)) Removing beliefs: -lier(john)

.send(tom,untell,lier(alice))


Goals

Types of goals:– Achievement goal: goal to do !write(book)

– Test goal: goal to know ?lier(john)

Adding goals: – !write(book) .send(tom,achieve,write(book));

– ?lier(john).send(tom,askOne,lier(john),Answer);

Removing goals: – .send(tom,unachieve,write(book))


Trigerring Events

Events happen as consequence to changes in the agent's beliefs or goals

An agent reacts to events by executing plans Types of plan triggering events

+b (belief addition)

-b (belief deletion)

+!g (achievement-goal addition)

-!g (achievement-goal deletion)

+?g (test-goal addition)

-?g (test-goal deletion)


Plans

An AgentSpeak plan has the following general structure:

triggering event : context <- body.

where: the triggering event denotes the events that the plan is meant to

handle the context represent the circumstances in which the plan can

be used the body is the course of action to be used to handle the event

if the context is believed true at the time a plan is being chosen to handle the event


Plans - Example

+green patch(Rock)[source(percept)]

: not battery charge(low)

<- ?location(Rock,Coordinates);

!at(Coordinates);

!examine(Rock).

+!at(Coords)

: not at(Coords) & safe path(Coords)

<- move towards(Coords);

!at(Coords).

+!at(Coords)

: not at(Coords) & not safe path(Coords)

<- ...

+!at(Coords) : at(Coords).


jEdit Plugin


Documents

Implementando os SMA