Agentes Inteligentes - PBJUG - Grupo de Usuários Java da Paraíba

Agentes Inteligentes: Uma
Abordagem Prática com o Java Agent
Development Framework
Daniel Abella Cavalcante Mendonça de Souza
[email protected]
Capítulo 1. Introdução
Segundo Russel e Norvig [1], um Agente é tudo o que pode ser considerado capaz de
perceber seu ambiente por meio de sensores e agir sobre este ambiente por
intermédio de atuadores. Este conceito é ilustrado a seguir.
Ilustração 1: Arquitetura básica de um Agente
Termos Utilizados
O termo percepção se refere às entradas perceptivas do agente em um dado
momento, enquanto que, temos uma seqüência de percepções, que diz respeito à
história completa de tudo o que o agente já percebeu.
Esta distinção entre os termos apresentados é necessária, pois, a escolha de
uma ação a ser realizada pelos atuadores do Agente, pode depender da seqüência
inteira de percepções observadas até o momento. Em termos matemáticos, afirmamos
que o comportamento do agente é descrito pela função de agente, que mapeia
qualquer seqüência de percepções a uma dada ação.
Função de Agente x Programa de Agente
O mapeamento descrito anteriormente na função agente é comumente relacionado a
uma tabela, que é infinita, a menos que seja definido um limite sobre a quantidade de
percepções que devemos considerar. Entretanto, esta tabela é apenas uma
caracterização externa do agente. Internamente, a função de agente é implementada
por um programa de agente.
Em resumo, a função de agente é uma descrição matemática abstrata; o
programa de agente é uma implementação concreta, relacionada à arquitetura do
agente.
Aplicação
Na próxima seção, é apresentada como pode ser desenvolvido um Agente conforme o
conceito de Russel e Norvig [1].
1.1 Implementação de um Agente “by Russel”
Para o desenvolvimento de um Agente Inteligente conforme a definição de Russel será
utilizada a linguagem Java e o framework Java Agent Development Framework – Jade
[2].
Caso o leitor não tenha conhecimento sobre a configuração do ambiente para
execução de Agentes ou desconheça conceitos básicos sobre este framework, devem
ser consultados respectivamente os apêndices A e B.
Então, Are you ready?
1.1.1 Prática
O primeiro passo para a construção de um Agente conforme a definição de Russel e
Norvig, é definir o(s) seu(s) atuador(es) e sensor(es).
Em termos de implementação, cada atuador ou sensor presente no agente,
significará a criação de um novo Behavior. Iniciaremos pela construção do Sensor do
agente intitulado Russel.
Sensor
Para o exemplo apresentado aqui, projetaremos um agente que perceberá o seu
ambiente periodicamente. As ações que o agente realizará durante a percepção do
agente é algo que deve corresponder à finalidade do agente.
Por exemplo, em um agente intitulado SubmarinoProducts, que atua no
oferecimento de produtos ao consumidor, pode constantemente monitorar as ações
do usuário no e-commerce, e atualizar no banco de dados as ações do usuário, algo
como o apresentado no Quadro 1. Em contrapartida, o atuador deste agente
consultaria esta tabela no banco de dados e realizaria uma oferta baseada na
quantidade de acessos.
Usuário
Página
Quantidade de Acessos
daniel.abella
eshop.com/notebook
3000
daniel.abella
eshop.com/palmtop
1400
daniel.abella
eshop.com/books
13
Quadro 1: Relação de acesso ao usuário Daniel Abella
Neste momento, temos que definir se criaremos um comportamento próprio
para o sensor (isto é, uma subclasse de SimplerBehavior) ou utilizaremos como base
algum dos behaviors disponibilizados pelo framework Jade (por exemplo,
CyclicBehavior, TickerBehavior, entre muitos outros).
Conforme dito anteriormente, o sensor perceberá o ambiente periodicamente,
logo pode ser utilizado como base o comportamento TickerBehavior, disponibilizado
pelo framework. Este comportamento permite que o behavior seja chamado de
acordo com a periodicidade informada pelo agente (em milisegundos). O código fonte
referente ao sensor é apresentado na seqüência.
Classe Sensor
import jade.core.Agent;
import jade.core.behaviours.TickerBehaviour;
public class Sensor extends TickerBehaviour {
public Sensor(Agent agente, long tempo){
super(agente,tempo);
}
protected void onTick(){
//Aqui, voce deve fornecer a implementacao do seu sensor
System.out.println("Agente percebendo o ambiente");
//Depois de perceber o ambiente, é designado um Atuador para atuar no ambiente
myAgent.addBehaviour(new Atuador());
}
}
No código fonte apresentado anteriormente, não temos nenhuma percepção
do ambiente de fato, apenas a impressão da frase “Agente percebendo o ambiente”.
Ao fim da percepção, é incluído um Atuador que poderá atuar sobre o ambiente.
Em substituição a impressão da frase “Agente percebendo o ambiente”
poderíamos ter implementado o comportamento descrito no Quadro 1. Um
pseudocódigo que ilustra este cenário é apresentado a seguir.
Classe Sensor
import jade.core.Agent;
import jade.core.behaviours.TickerBehaviour;
public class Sensor extends TickerBehaviour {
public Sensor(Agent agente, long tempo){
super(agente,tempo);
}
protected void onTick(){
String usuarioVerificado = obterUsuarioAutenticado();
String acaoUsuario = obterAcaoUsuario(usuarioVerificado);
gravarBancoDeDados(usuarioVerificado,acaoUsuario);
myAgent.addBehaviour(new Atuador());
}
private void gravarBancoDeDados(String usuarioVerificado, String acaoUsuario) {}
private String obterAcaoUsuario(String usuarioVerificado) {return null;}
private String obterUsuarioAutenticado() {return null;}
}
Atuador
Após a definição do Sensor, trataremos nesta subseção a definição do atuador.
Conforme apresentado nos códigos fonte anteriormente, o atuador estava sempre
sendo chamado após a realização da atividade do sensor (note que, é sempre colocado
no final do método onTick).
Baseado nisto, tem-se que o Atuador deve ser chamado apenas uma vez. Isto
se deve ao fato que, como o Sensor é chamado periodicamente e este último, por sua
vez, sempre realizada a chamada do Atuador.
Em momento simular durante o desenvolvimento do Sensor, temos que definir
se criaremos um comportamento próprio para o atuador (isto é, uma subclasse de
SimplerBehavior) ou utilizaremos como base algum dos behaviors disponibilizados
pelo framework Jade (por exemplo, CyclicBehavior, TickerBehavior, entre muitos
outros). Neste sentido, o OneShortBehavior pode ser utilizado, pois este implementa
um comportamento atômico que é executado uma vez.
É apresentado a seguir o código fonte referente ao atuador. Neste exemplo,
não temos nenhuma atuação de fato, apenas a impressão da frase “Agente Russel
atuando no ambiente”. Após isto, o método removeBehavior é chamado. Este método
faz com que o behavior informado como argumento seja removido da execução. Logo,
quando temos a chamada da forma removeBehavior(this) estamos pedindo para que
o próprio Atuador acabe com a sua execução.
Classe Atuador
import jade.core.behaviours.OneShotBehaviour;
public class Atuador extends OneShotBehaviour{
public void action() {
System.out.println("Agente Russel atuando no ambiente");
myAgent.removeBehaviour(this);
}
}
Em contrapartida ao realizado durante a apresentação do Sensor, é
apresentado abaixo o pseudocódigo para um Atuador que representaria o
comportamento descrito no Quadro 1.
Classe Atuador
import jade.core.behaviours.OneShotBehaviour;
public class Atuador extends OneShotBehaviour{
public void action() {
String usuarioVerificado = obterUsuarioAutenticado();
String secaoMaisAcessadaPeloUsuario =
obterSecaoMaisAcessadaPeloUsuario(usuarioVerificado);
String paginaOfertasSessao =
obterOfertasDaSessao(secaoMaisAcessadaPeloUsuario);
enviarEmailUsuario(paginaOfertasSessao);
myAgent.removeBehaviour(this);
}
private void enviarEmailUsuario(String paginaOfertasSessao) {}
private String obterOfertasDaSessao(String
secaoMaisAcessadaPeloUsuario) {return null;}
private String obterSecaoMaisAcessadaPeloUsuario(String
usuarioVerificado) {return null;}
private String obterUsuarioAutenticado() {return null;}
}
Vídeo Aula e Código Fonte
Para melhor compreensão do abordado até este momento, é disponibilizado no site da
disciplina uma vídeo-aula que demonstra a criação do Agente Russel. Além disto, é
disponibilizado o código fonte produzido.
Apêndice A. Configuração do Ambiente para
Desenvolvimento de Agentes Inteligentes com
o Java Agent Development Framework
A ser incluído.
Apêndice B. Conceitos básicos sobre o Java
Agent Development Framework
A ser incluído.