JADE Java Agent Development Framework

http://jade.tilab.com/

JADE

Jade é um framework para o desenvolvimento de SMA

Versão 3.6

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)– Oferecer 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

– Utiliza o método “round-robin”

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 MAS

– 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 executando

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

Comunicação entre os agentes II/III

Para se receber uma mensagem se pode utilizar os métodos–receive(): tira da fila a primeira mensagem. Se a fila está vazia

retorna null–blockingReceive(): se não existe uma mensagem na fila,

bloqueia a execução do agente para esperar a mensagem

ACLMessage msg = receive();if (msg != null) { // Procesar el mensaje}

ACLMessage msg = new ACLMessage( ACLMessage.INFORM );msg.addReceiver( new AID( "Agente2", AID.ISLOCALNAME ) );msg.setLanguage( "English" );msg.setOntology( "Weather-forecast-ontology" );msg.setContent( "Today it’s raining" );send(msg);

Comunicação entre os agentes III/III

É possível buscar uma mensagem de um determinado tipo na fila utilizando a classe MessageTemplate

public void action() { MessageTemplate mt; mt = MessageTemplate.MatchPerformative(ACLMessage.CFP); ACLMessage msg = myAgent.receive(mt); if (msg != null) { // Mensaje del tipo CFP recibida ... } else blockingReceive();}

Registrando um serviço no DF (páginas amarelas)

Se cria um objeto do tipo ServiceDescription e se clama o método register() do DF

– Normalmente se faz isso no método setup() do agente

protected void setup() { ... // Registrar un agente vendedor de libros en el DF DFAgentDescription dfd = new DFAgentDescription(); dfd.setName(getAID());

ServiceDescription sd = new ServiceDescription(); sd.setType("book-selling"); sd.setName("JADE-book-trading"); dfd.addServices(sd);

try { DFService.register(this, dfd); } catch (FIPAException fe) { fe.printStackTrace(); } ...}

Removendo um serviço do DF

Chamar o método deregister() do DF– Normalmente se faz isso no método takeDown() do agente

protected void takeDown() { // Saliendo del DF try { DFService.deregister(this); } catch (FIPAException fe) { fe.printStackTrace(); }

// Enseñando el mensaje de salida System.out.println("Agente vendedor " + getAID().getName() + " terminando");}

Buscando por serviços no DF

Criar um objeto DFAgentDescription e clamar o método search() do DF

protected void setup() { ... // Creando un TickerBehaviour para buscar agentes vendedores a cada minuto addBehaviour(new TickerBehaviour(this, 60000) { protected void onTick() { // Actualizando la lista de agentes vendedores DFAgentDescription template = new DFAgentDescription(); ServiceDescription sd = new ServiceDescription(); sd.setType("book-selling"); template.addServices(sd);

try { DFAgentDescription[] result = DFService.search(myAgent, template); sellerAgents = new AID[result.length]; for (int i = 0; i < result.length; ++i) sellerAgents[i] = result[i].getName(); } catch (FIPAException fe) { fe.printStackTrace(); } ... } ); ...}

Jadex

http://vsis-www.informatik.uni-hamburg.de/projects/jadex/

Jadex

Jadex = Jade + BDI

No Jadex os agentes são orientados a objetivos (e não a comportamentos como é o caso de agentes JADE)

Desenvolvido na Universidad de Hamburg– Versão 0.96

É possível utilizar todas as ferramentas JADE mais:– Ferramenta BDI Viewer possibilita ver o estado interno dos agentes,

i.e., seus objetivos, planos e crenças

– Ferramenta Jadex Introspector possibilita vigiar o comportamento do agente e também modificar a execução dos agentes

Jadex

Objetivos em Jadex

Tipos de objetivos

Perform (fazer):– Alguma coisa deve ser feita mas não se espera um resultado específico.

Ej: pegar o lixo

Achieve (alcançar):– Descreve um estado que se deseja alcançar

– Diferentes alternativas de execução (planos) podem ser utilizadas

– Ex.: lixo recolhido

Query (perguntar):– Representa a necessidade de obter uma informação

– Ex.: quer saber onde está o lixo

Maintain (manter):– Especifica um estado que deve ser mantido quando seja alcançado

– Ex.: manter o ambiente sem lixo

Modelo de execução do agente

Implementando o agente

Criar os tipos de arquivos– ADF (Agent Definition File): arquivo XMI que descreve tipos (ou

classes) de agentes

– Classes Java: arquivos que implementam os planos dos agentes

ISMA Viviane Torres da Silva

Arquivo ADF

Quando o arquivo ADF é carregado no Jadex, objetos são criados de acordo com a especificação

Classes e pacotes de Java utilizados

Encapsula comportamento (=Jade)(define objetivos, crenças e planos associados á capacidade)

Dois tipos de eventos: eventos internos e mensagens

Expressões verificadas na execução

Propriedades que ajudam na execuçãoInforma se o dado será criado quando o agente é criado ou quando termina

Planos I/II

ADF: especificamos quando o plano deve ser executado Classe: descrevemos a implementação do plano

Devemos estender uma das classes:–ThreadedPlan ou NonThreadedPlan

Devemos implementar o método body()

Devemos colocar a referência à classe do plan no arquivo ADF (incluindo o import para o pacote onde está a classe)

Plano pode ser– Ativo: sempre em execução– Passivo: criado a cada evento

Planos II/II

ObjetivosMensagens

Base de Crenças I/II

Representa o conhecimento dos agentes sobre o ambiente

Deve estar declarada no arquivo ADF

É possível consultar, adicionar e remover objetos da BeliefBase dinamicamente

Base de Crenças II/II

Tipos de objetivos

Referências a outros objetivos definidos em capacidades

Objetivos I/II

O objetivo é adotado uma ou mais vezes

Condição de criação

Condição para suspenderCondição para deixar

(eliminado o conj. de objetivos do agente)

Estratégia de seleção

Objetivo II/II