Programação de Agentes em uma
Linguagem Orientada a Objetos:
a Solução EOOPS
Abordagens de programação
EOOPS: Integração objetos-regras de produção
JEOPS
1
Exemplos Atuais de Aplicações
Complexas
Recuperação de Informação na Internet
• Informação desorganizada e enorme
Comércio Eletrônico
• Vários sites, produtos, preços, prazos, etc.
Jogos Eletrônicos
• Realismo e oponentes competitivos
2
Pontos em comum
Aplicações 3M
• Muito grande (muitas linhas de código)
• Muita gente
• Muitos e variados serviços (componentes)
Serviços IA (dedução, indução, comunicação,...)
• Modelo das preferências do usuário, coordenação de ações,
comportamento dirigido a objetivos,... tudo encapsulado no
conceito de agente
Serviços não-IA
• BD, GUI, WWW, Mobilidade, ...
3
Consequentemente, é preciso...
Engenharia de Software
• Metodologia, gerência e qualidade de software
Material humano qualificado
• Cada vez mais escasso
Reutilização e integração de componentes
(serviços)
• Não “reinventar a roda”
• Questão: como integrar e facilitar reutilização?
4
Como implementar os agentes?
“Linguagens de IA”
• Orientadas a agentes (ex. Agent0, Placa, 3APL)
• Programação em lógica (prolog)
+ Oferecem os serviços básicos dos agentes
+ Coesão
- Sistemas desenvolvidos não são facilmente
integráveis
AIOL
- Poucos componentes a
(AI-Oriented
reutilizar e pouca gente
Language)
- Metodologia?
Reasoning
Mechanism
5
Como implementar os agentes?
Linguagens orientadas a objetos
• Java, C++, ...
+ Facilitam a reutilização e integração de serviços
+ Engenharia de software
+ Mão de obra disponível
- Não oferecem de antemão as
funcionalidades dos agentes (raciocínio)
Host
AI-Oriented
Language
Language
6
Integração Objetos / Regras de produção
Por que não ter o melhor dos mundos?
7
Como integrar dedução com OO?
OO dentro de IA
• ex. ObjLog (fim dos anos 80), LIFE, ....
+ trata herança mais facilmente
- mesmos problemas de integração com outros
sistemas e de pouca reutilização
AIOL
Reasoning
Mechanism
OO
Mechanisms
8
Como integrar dedução com OO?
IA e OO cooperando
• ex. Jasper, JavaLog, InterProlog (fim anos 90)
+ técnica promissora mas...
- requer dupla habilidade de programação
- pode não ser eficiente ou viável
Tempo de execução
AI AIOL
Host
Host
Language
Language
Reasoning
Mechanism
9
Como integrar dedução em OO?
IA dentro de OO
• Abordagem 1: Tradução
• ex. Prolog Café , jProlog, Minerva and Jinni
• “Caixa preta”
• Muito bom mas ainda requer dupla habilidade
Host
Language
Translator
AI-Oriented
AI-Oriented
Language
Language
Reasoning
Mechanism
10
Como integrar dedução em OO?
IA dentro de OO
• Abordagem 2: Novas Agent-Oriented (Hybrid)
Programming Languages
• Primitivas redefinidas/extendidas!!!
• ex. Jack e AgentJava
- excelentes (caixa branca) mas ainda incipientes....
Extended Host
Language
Knowledge
Base
-- - - ----- - - ---- - - - - --- - - ----- - - - -
11
Como integrar dedução com OO?
IA dentro de OO
• Abordagem 3: API
• ex. CLIPS, NéOpus, RAL/C++ (meados dos anos 80)
• Implementação mais usada: EOOPS
• Embedded Object-Oriented Production Systems
• Linguagem OO + Sistema de Produção
Host
Host
Language
Language
Reasoning
Mechanism
Knowledge
Base
-- - - ----- - - ---- - - - - --- - - ----- - - - -
12
EOOPS
Embedded Object-Oriented Production Systems
13
Lembrete sobre sistemas de produção
Conjunto de
• Base de regras de produção
• Base de fatos
• Conjunto de conflitos (das regras disparáveis)
Passos (encadeamento progressivo)
• Unificação da condições das regras com os fatos
• Resolução de conflitos entre regras ativas
• Execução das ações da regra escolhida
14
Lembrete sobre sistemas de produção
Base de
Regras
Base de
fatos
Motor de Inferência
unificação
Pai(João, José)
Pai(José, Marcos)
p1, p2, p3:
Pai(p1,p2) Pai(p2,p3)
Avo(p1,p3)
Avo(João, Marcos)
15
Lembrete sobre sistemas de produção
Base de Regras
unificação
Base de Fatos
Conjunto de Conflito
resolução
de conflitos
Ciclo
Regra
execução
Adiciona/Retira Fatos
Obs: para não ter de re-testar a cada ciclo, só testa os fatos
modificados (retirados, adicionados)
16
Integração Objetos/Regras
Mudança filosófica
• Fatos: string => Objetos
• Predicados: string => métodos dos objetos
• Casamento estrutural => Casamento comportamental
(pertinência a classes + veracidade dos predicados)
p1, p2, p3: Pai(p1,p2)
Pai(p2,p3) Avo(p1,p3)
Pai(João, José)
Pai(José, Marcos)
Nome:
Marcos
Pessoa
pai
Nome:
José
Pessoa
pai
Nome:
João
Pessoa
Regra Avo
Para todo objeto p1, p2 e p3
da classe Pessoa,
SE
p1.ehPai(p2);
p2.ehPai(p3);
ENTÃO
Integração Objetos/Regras em
EOOPS: características
Eficiência
• RETE?
Expressividade
• ordem lógica (0, 0+, 1) implementada?
Encadeamentos
• Progressivo e/ou regressivo?
Estratégias de Controle
• Flexível? Declarativa?
Uniformidade da integração
18
Uniformidade da Integração
Aspectos
• Sintático: como aparentam as regras?
• Semântico: quão respeitados são os conceitos da
linguagem OO?
Vantagens
• Facilidade de uso
• Engenharia de Software: reutilização,
modularidade, extensibilidade, ...
19
Uniformidade da Integração
Desvantagens: modified problem
• Encapsulamento não permite ao motor de
inferência “ver” as mudanças em um objeto (fato)
• ex. como saber se um objeto Pessoa passou a ter
avô sem precisar perguntá-lo (de novo)?
20
Integração Objetos/Regras:
Algumas Propostas
Sistema
Ling.
Progr.
CLIPS
C++
-
-
+/-
-
RAL/C++
C++
+/-
+
+
-
+
-
+/-
+
NéOpus Smalltalk
Unif.
Resol.
Serviços Eficiência Encad.
Integr.
Conflitos
JESS
Java
-
+/-
+/-
-
JEOPS
Java
+
+
+/-
+/-
21
Regras CLIPS
Nem todos objetos são utilizados
(defclass Pessoa (is-a USER) (role concrete)
(pattern-match reactive)
(slot nome (create-accessor read-write))
(slot pai (create-accessor read-write)))
As regras tem sintaxe própria (lisp-like)
(defrule RegraAvo
"O pai do pai de alguém é seu avô”
?a <- (object (is-a Pessoa) (nome ?nomeAvo))
?p <- (object (is-a Pessoa) (nome ?nomePai) (pai ?a))
(object (is-a Pessoa) (nome ?nomeNeto) (pai ?p))
=>
(printout t ?nomeAvo “ é avô de ” ?nomeNeto crlf)
)
22
CLIPS
Outras caraterísticas
• COOL (CLIPS Object-Oriented Language)
• Foi uma linguagem utilizada bem difundida (>
5.000 usuários)
Aplicações
• medicina, multiagentes, helpdesk, aplicações
aeroespaciais, etc.
Sites
• http://herzberg.ca.sandia.gov/jess/
• http://www.ghg.net/clips/CLIPS.html
23
Regras RAL/C++
Utiliza classes C++, se indicado
class Pessoa {
public:
char nome[20]; Pessoa pai;
...
}
wmedef PessoaMT:Pessoa {}
Sintaxe um pouco mais próxima à de C++
RegraAvo {
// O pai do pai de alguém é seu avô
Avo (PessoaMT nome::NomeAvo)
Pai (PessoaMT nome::NomePai pai==Avo)
Neto (PessoaMT nome::nomeNeto pai==Pai)
-->
printf(“%s é avô de %s\n”, NomeAvo, NomeNeto);
)
24
Regras NéOpus
Toda classe Smalltalk
Object subclass: #Pessoa
instanceVariableNames: ‘nome pai’!
Regras com sintaxe de Smalltalk
RegraAvo
“O pai do pai de alguém é seu avô”
| Pessoa a p n |
a = p pai.
p = n pai.
actions
Transcript show: a nome, ‘ é avô de ’, n nome, cr.!
25
NéOpus
ViraCasaca
| Pessoa p|
(p timePreferido) nome = “Santa Cruz”.
Actions
| Time bom |
bom := Time new.
Pessoa
bom nome: “Sport”.
nome
p timePreferido: bom.
idade
P modified.
timePreferido(): Time
timePreferifo(t : Time)
time
Time
nome
nome(): String
nome(n : String)
26
NéOpus
www-poleia.lip6.fr/~fdp/NeOpus.html
Outras características
• Bases de regra são representadas por classes
abstratas (herança!)
• Controle declarativo (via Metabase)
Aplicações
• controle de aparelhos respiratórios, prova de
teoremas, transformação de modelo de dados,
análise de harmônicas, Actalk,...
Infelizmente...
• SmallTalk dançou!
27
Regras JESS (CLIPS para Java)
Pode usar classes Java, com restrições
class Pessoa {
private String nome;
private Pessoa pai;
...
}
(defclass Pessoa Pessoa)
Regras com sintaxe própria (lisp-like)
(defrule RegraAvo
"O pai do pai de alguém é seu avô”
?a <- (Pessoa (nome ?nomeAvo))
?p <- (Pessoa (nome ?nomePai) (pai ?a))
?n <- (Pessoa (nome ?nomeNeto) (pai ?p))
=>
(printout t ?nomeAvo “ é avô de ” ?nomeNeto crlf)
)
28
JEOPS
Java Embedded Object Production System
Made in Cin (1997/2-2000/1)
http://www.di.ufpe.br/~jeops/
http://sourceforge.net/projects/jeops/
29
JEOPS - Princípios
Java
• 1001 serviços
Uniformidade total de integração
• Reutilização de componentes
• Engenharia de Software
Facilidade de uso
• Fachada única de acesso
30
JEOPS - Arquitetura
Agente
assert
run
objects
flush
JEOPS
ClassFilter
Decl 1
ClassFilter
Decl 2
ClassFilter
Decl 3
FilterNode
Decl 1
FilterNode
Decl 2
FilterNode
Decl 3
JoinNode
Decl 1
JoinNode
Decls 1 a 2
JoinNode
Decls 1 a 3
Rete
Gera
entradas
Conjunto de Conflito
FinalNode
Regra n
Consulta
Knowledge
Base
-- - - ----- - - ---- - - - ---- - - ----- - - --
Base Interna
de Regras
Base de
Objetos
Base de
Conhecimentos
Assert = insere objetos na base de objetos
Objects = recupera objetos da base de objetos
Flush = limpa base de objetos (fatos)
31
JEOPS
JEOPS
Compilation
CompilationEnvironment
Environment
Rule Base
JEOPS
Rule Base
(.rules)
Rule Pre-Compiler
(.java)
Esquema
de
Compilação
• Mais simples de
implementar
• Mais rápido de
executar
JEOPS
Engine
Application
JAVA
(.java)
Compiler
ByteCodes
(.class)
JAVA
JEOPS
JEOPS
Runtime
RuntimeEnvironment
Environment
JEOPS
Inference Engine
32
Regras JEOPS
Rule ::= "rule" "{" <Rule Body> "}"
Rule Body ::= <Declarations> <Local Declarations>?
<Conditions> <Actions>
Declarations ::= "declarations" (<class name> <ident> (","
<ident>)* )*
Local Declarations ::= "localdecl" (<class name> <ident> "="
<expression>)*
Conditions ::= "conditions" (<expression>)*
Actions ::= (Action)+
Action ::= "assert" "(" <expression> ")" | "retract" "("
<expression> ")" | "modified" "(" <expression> ")" | <block>
33
JEOPS - Exemplo de Utilização
Definição das classes
• Jogador, Time, Partida, ...
class Jogador {
private Time time;
private int habilidade;
...
}
class Partida {
private int etapa;
private int tempo;
...
}
class Time {
private Jogador[] jogs;
...
}
class Goleiro extends
Jogador {
...
}
class Atacante extends
Jogador {
...
}
class Meia extends
Jogador {
...
}
34
JEOPS - Exemplo de Utilização
Criação das regras
rule Retranca {
declarations
Partida p;
// para toda instância p da classe Partida
Jogador a;
// para toda instância a da classe Jogador
localdecl
Time meuTime = a.getTime();
conditions
p.getEtapa() == 2; // Estamos no segundo tempo, ...
p.getPlacar(meuTime) >= p.getPlacarAdversario(meuTime);
meuTime.getCategoria() <
// ... e eu sou ruim
p.getTimeAdversario(meuTime).getCategoria();
actions
a.vaParaDefesa(); // Então bola pro mato...
modified(a);
}
35
JEOPS - Exemplo de Utilização
Criação dos objetos
RegrasFutebol base = new RegrasFutebol();
Time camaroes = new Time(“Camaroes”);
base.assert(camaroes);
base.assert(new Atacante(camaroes, “MBoma”));
base.assert(new Lateral(camaroes, “Mila”));
base.assert(new Meia(camaroes, “Nkekessi”));
base.assert(new Goleiro(camaroes, “Silva”));
...
base.assert(new Partida(brasil, camaroes));
Execução do motor de inferência
base.run();
36
JEOPS - Outras Características
Pré-compilação de regras
• Regras convertidas em classes Java
• comando:
• java jeops.compiler.Main nome_do_arquivo.rules
Rete
• Algoritmo eficiente de unificação
Aplicações
• Administração de rede, Jogos interativos
(NetMaze, Enigmas, Guararapes), Recuperação
de Informação, Geração de variações fonéticas
37
JEOPS - Outras Características
Resolução de conflitos
• Mecanismo flexível de definição de políticas
Classes
•
•
•
•
•
LRUConflictSet
MRUConflictSet
NaturalConflictSet
OneShotConflictSet
PriorityConflictSet
38
Passos para o desenvolvimento de
aplicações
1. Definir as classes
• Atributos e métodos
2. Definir as regras
• Interação entre os objetos da base
3. Voltar ao passo 1
4. Escolher estratégia de resolução de conflito
5. Deixar a base de conhecimentos trabalhar...
39
Estudo de Caso com o JEOPS:
Definindo estratégias de combate
40
JEOPS - Estudo de Caso
O ambiente:
• Vários jogadores, cada um
com sua civilização
• Cada civilização é
composta por várias
cidades, localizadas em
diversos pontos do mapa
• Cada civilização tem um
exército que pode ser
usado para conquistar
novas cidades ou defender
as suas próprias cidades
41
JEOPS - Estudo de Caso
Pensando nas classes...
Jogador
- nome: String
- pais: String
Cidade
- nome: String
- dono: Jogador
- local: Localizacao
UnidCombate
- nome: String
- dono: Jogador
- movim: int
- local: Localizacao
ataca(e: UnidCombate)
anda(l: Localizacao)
Localizacao
- linha: int
- coluna: int
dist(l:Localizacao): int
JEOPS - Estudo de Caso
Pensando nas regras...
rule defendeCidade { // Se houver algum inimigo por perto da
declarations
//minha cidade, é melhor atacá-lo primeiro
Jogador eu;
Cidade cid;
UnidCombate exercAdv;
.....
Mas eu preciso usar o meu melhor soldado para atacar o inimigo!!!
- Quem é este soldado?
JEOPS - Estudo de Caso
Jogador
- nome: String
- pais: String
Repensando nas classes...
Cidade
- nome: String
- dono: Jogador
- local: Localizacao
melhorUnidade(): UnidCombate
UnidCombate
- nome: String
- dono: Jogador
- movim: int
- local: Localizacao
ataca(e:UnidCombate)
anda(l:Localizacao)
Localizacao
- linha: int
- coluna: int
dist(l:Localizacao): int
JEOPS - Estudo de Caso
Repensando nas regras...
rule defendeCidade { // Se houver algum inimigo por perto,
declarations
// é melhor atacá-lo primeiro
Jogador eu;
Cidade cid;
UnidCombate exercAdv;
preconditions
eu.getNome().equals(“Carlos”);
cid.melhorUnidade() != null; // Ou eu estaria perdido!
cid.getDono() == eu;
exercAdv.getDono() != eu; // Ele realmente é meu adversário?
cid.getLocal().dist(exercAdv.getLocal()) <= exercAdv.getMovim();
actions
cid.melhorUnidade().ataca(exercAdv);
}
Mas se eu estiver em tratado de paz com o meu adversário? Devo atacá-lo?
Além disso, vamos tornar o código mais legível...
JEOPS - Estudo de Caso
Repensando nas classes...
Jogador
- nome: String
- pais: String
Cidade
- nome: String
- dono: Jogador
- local: Localizacao
emPaz(j:Jogador):bool
melhorUnidade(): UnidCombate
podeSerAlcançada
(u:UnidCombate): boolean
UnidCombate
- nome: String
- dono: Jogador
- movim: int
- local: Localizacao
ataca(e:UnidCombate)
anda(l:Localizacao)
Localizacao
- linha: int
- coluna: int
dist(l:Localizacao): int
JEOPS - Estudo de Caso
Repensando nas regras...
rule defendeCidade { // Se houver algum inimigo por perto,
declarations
// é melhor atacá-lo primeiro
Jogador eu;
Cidade cid;
UnidCombate exercAdv;
preconditions
eu.getNome().equals(“Carlos”);
cid.melhorUnidade() != null; // Ou eu estaria perdido!
cid.getDono() == eu;
exercAdv.getDono() != eu; // Ele realmente é meu adversário?
cid.podeSerAlcançada(exercAdv);
!eu.emPaz(exercAdv.getDono());
actions
cid.melhorUnidade().ataca(exercAdv);
}
JEOPS - Estudo de Caso
E se a cidade estiver desprotegida?
• Mais uma regra para tratar deste caso!
rule defendeCidade2 {
declarations
Jogador eu;
Cidade cid;
UnidCombate exercAdv, meuExerc;
preconditions
eu.getNome().equals(“Carlos”);
cid.melhorUnidade() == null; // Problemas a vista!!!
cid.getDono() == eu;
meuExerc.getDono() == eu;
exercAdv.getDono() != eu; // Ele realmente é meu adversário?
cid.podeSerAlcançada(exercAdv);
cid.podeSerAlcançada(meuExerc);
actions
meuExerc.anda(cid.getLocal()); // Corra para proteger a cidade!
}
JEOPS - Estudo de Caso
Já sei me defender... quero agora ampliar
meus domínios...
rule atacaCidade { // Se eu estiver perto de uma cidade inimiga,
declarations
// devo atacá-la!!!
Jogador eu;
Cidade cid;
UnidCombate meuExerc;
preconditions
eu.getNome().equals(“Carlos”);
cid.getDono() != eu;
meuExerc.getDono() == eu;
meuExerc.getAtaque() >= 3; // Não vou atacar com qualquer um
cid.podeSerAlcançada(meuExerc);
!eu.emPaz(cid.getDono());
actions
meuExerc.ataca(cid.getLocal());
}
JEOPS - Estudo de Caso
Repensando nas classes...
Jogador
- nome: String
- pais: String
Cidade
- nome: String
- dono: Jogador
- local: Localizacao
emPaz(j:Jogador):bool
melhorUnidade(): UnidCombate
UnidCombate
- nome: String
- dono: Jogador
- movim: int
- local: Localizacao
- ataque: int
- defesa: int
ataca(e:UnidCombate)
anda(l:Localizacao)
Localizacao
- linha: int
- coluna: int
dist(l:Localizacao): int
JEOPS - Estudo de Caso
Ou ainda eu posso criar uma nova cidade...
rule criaCidade {
declarations
A decisão de criar uma cidade
Jogador eu;
pode requerer uma base de
Settler meuExerc;
conhecimento à parte
preconditions
eu.getNome().equals(“Carlos”);
meuExerc.getDono() == eu;
meuExerc.getLocal().haOceanoPorPerto();
meuExerc.getLocal().haComidaPorPerto();
!meuExerc.getLocal().haCidadePorPerto();
actions
Cidade nova = new Cidade(eu);
retract(meuExerc);
assert(nova);
}
JEOPS - Estudo de Caso
Repensando nas classes...
Localizacao
- linha: int
- coluna: int
dist(l:Localizacao): int
haComidaPerto() : boolean
haCidadePerto() : boolean
haOceanoPerto() : boolean
JEOPS - Estudo de Caso
Colocando tudo para funcionar...
Civ2.java:
public static void main(String[] args) {
KnowledgeBase kb = new KnowledgeBase(“regrasciv.rules”);
Jogador eu;
kb.insert(eu = new Jogador(“Carlos”, “Brasil”));
kb.insert(new Settler(eu, Localizacao.getRandom()));
...
kb.run();
}
Considerações Finais sobre a
Integração Objetos/Regras
Vantagens
• Reutilização, modularidade, legibilidade,
extensibilidade, ...
• Separação clara entre ontologia e regras (IA)
• Facilidade de aprendizado (disponibilidade de
gente)
54
Considerações Finais sobre a
Integração Objetos/Regras
Desvantagem: falta de metodologia
• O que vai para as regras e o que vai para os
objetos?
• Dica: procedimentos, conhecimento consolidado,
cálculos eficientes, serviços diversos (ex. BD, WWW) , ...
=> métodos
• Executa logo “dentro da base”?
• Parte ação das regras: agenda ou executa?
• Agente dentro e fora da KB?
55
Agentes x Base de Conhecimento?
Centralizado x Distribuído
Agentes estão dentro da base de objetos
• Por exemplo jogadores estão dentro de uma base
sobre jogar futebol...
• É como se fosse um agente externo (a base do agente
“técnico”)
Cada agente tem sua BC (atributo)
•
•
•
•
•
Ciclo {
Percepções => base de objetos (da BC)
Run BC
Recupera da BC ações a serem executadas
Executa ações}
56
Considerações Finais sobre a
Integração Objetos/Regras
Desvantagem: modificação
• Detecção da modificação de objetos devido ao
encapsulamento
• Modificação direta e transitiva....
57
Referências
• Masini et al - Object Oriented Languages (Cap 9)
• Proceedings of the OOPSLA’94 - workshop on Embedded ObjectOriented Production Systems
• Pachet F. - On the embeddability of production rules in objectoriented languages - Journal of Object-Oriented Programming, vol
8, No. 4
• Jennings, Sycara & Wooldridge (1998), Roadmap on Agents
Research and Development. Autonomous Agents and Amulti-Agent
Systems, 1
• Figueira Filho, C. & Ramalho, G. (2000). Jeops – the java
Embedded Object Production System. IBERAMIA-SBIA 2000. LNAI
1952, Berlin: Springer-Verlag
• Albuquerque, R., Guedes, P., Figueira Filho, C., Robin, J. &
Ramalho, G. (2002) Embedding J2ME-based Inference Engine in
Handheld Devices: The KEOPS Study Case. In Proceedings of 1st
Workshop on Ubiquitous Agents on Embedded, Wearable, and
Mobile Devices. In AAMAS’02, Bologna.
58
Download
