Programação de Agentes em uma Linguagem Orientada a Objetos: a Solução EOOPS

1

Programação de Agentes em uma Linguagem Orientada a Objetos:

a Solução EOOPS

Abordagens de programaçãoEOOPS: Integração objetos-regras de produção

JEOPS

2

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

3

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, ...

4

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?

5

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

- Poucos componentes a reutilizar e pouca gente

- Metodologia?

AIOL (AI-OrientedLanguage)

ReasoningMechanism

6

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)

AI-Oriented Language

HostLanguage

7

Integração Objetos / Regras de produção

Por que não ter o melhor dos mundos?

8

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

ReasoningMechanism

OO Mechanisms

9


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

Host Language

Host Language

AI AIOL

ReasoningMechanism

Tempo de execução

10

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



ReasoningMechanism

Translator

11

Extended Host

Language-- - - ------ - - ----- - - - - ---- - - ------ - - - -

Knowledge Base

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....

12


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

HostLanguage

HostLanguage

ReasoningMechanism

-- - - ------ - - ----- - - - - ---- - - ------ - - - -

Knowledge Base

13

EOOPSEmbedded Object-Oriented Production Systems

14

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

15


Base de Regras

p1, p2, p3:Pai(p1,p2) Pai(p2,p3) Avo(p1,p3)

Base defatos

Pai(João, José)Pai(José, Marcos)

Motor de Inferência

Avo(João, Marcos)Avo(João, Marcos)

unificação

16


Base de FatosBase de Regras unificação

Conjunto de Conflito

resoluçãode conflitos

Regra

Adiciona/Retira Fatos

execução

Ciclo

Obs: para não ter de re-testar a cada ciclo, só testa os fatos modificados (retirados, adicionados)

Mudança filosófica • Fatos: string => Objetos• Predicados: string => métodos dos objetos• Casamento estrutural => Casamento comportamental

(pertinência a classes + veracidade dos predicados)

Integração Objetos/Regras

Nome:Marcos

Nome:José

Nome:João

pai pai

Pessoa Pessoa Pessoa

Pai(João, José)Pai(José, Marcos)

p1, p2, p3: Pai(p1,p2) Pai(p2,p3) Avo(p1,p3)

Regra Avo Para todo objeto p1, p2 e p3 da classe Pessoa, SE p1.ehPai(p2); p2.ehPai(p3);ENTÃO

18

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

19

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, ...

Uniformidade da Integração

20

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

21

Integração Objetos/Regras:Algumas Propostas

CLIPS

RAL/C++

NéOpus

JESS

JEOPS

SistemaLing.Progr.

C++

C++

Smalltalk

Java

Java

Unif.Integr.

-

+/-

+

-

+

Serviços

-

+

-

+/-

+

Eficiência

+/-

+

+/-

+/-

+/-

Encad.Resol.

Conflitos

-

-

+

-

+/-

22

Regras CLIPS

Nem todos objetos são utilizados

As regras tem sintaxe própria (lisp-like)

(defclass Pessoa (is-a USER) (role concrete) (pattern-match reactive) (slot nome (create-accessor read-write)) (slot pai (create-accessor read-write)))

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

23

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

24

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

Regras RAL/C++

Utiliza classes C++, se indicado

Sintaxe um pouco mais próxima à de C++

class Pessoa { public: char nome[20]; Pessoa pai; ...}wmedef PessoaMT:Pessoa {}

25

Regras NéOpus

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.!

Toda classe Smalltalk

Regras com sintaxe de Smalltalk

Object subclass: #Pessoa instanceVariableNames: ‘nome pai’!

26

ViraCasaca | Pessoa p|

(p timePreferido) nome = “Santa Cruz”.

Actions

| Time bom |

bom := Time new.

bom nome: “Sport”.

p timePreferido: bom.

P modified.

NéOpus

Pessoa

nomeidade

timePreferido(): TimetimePreferifo(t : Time)

time

Time

nome

nome(): Stringnome(n : String)

27

NéOpuswww-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!

28

Pode usar classes Java, com restrições

Regras com sintaxe própria (lisp-like)

Regras JESS (CLIPS para Java)

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

class Pessoa { private String nome; private Pessoa pai; ...}(defclass Pessoa Pessoa)

29

JEOPS Java Embedded Object Production System

Made in Cin (1997/2-2000/1)http://www.di.ufpe.br/~jeops/

http://sourceforge.net/projects/jeops/

30

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

31

JEOPS - Arquitetura

Geraentradas

Agente

Base deConhecimentos

Base deObjetos

Rete

Base Internade Regras

Conjunto de Conflito

Consulta

JoinNodeDecls 1 a 2

FilterNodeDecl 1

ClassFilterDecl 1

FilterNodeDecl 2

ClassFilterDecl 2

JoinNodeDecls 1 a 3

FilterNodeDecl 3

ClassFilterDecl 3

FinalNodeRegra n

JoinNodeDecl 1

JEOPS

flushassert run objects

-- - - ------ - - ----- - - - ----- - - ------ - - --

Knowledge Base

Assert = insere objetos na base de objetosObjects = recupera objetos da base de objetosFlush = limpa base de objetos (fatos)

32

Esquemade Compilação

JEOPSCompilation Environment


JEOPSEngine

JEOPSRule Pre -Compiler

Rule Base(.rules)

Rule Base(.java)

Application(.java)

JAVACompiler

ByteCodes(.class)

JEOPSRuntime Environment


JEOPSInference Engine



JEOPSEngine

JEOPSRule Pre -Compiler

Rule Base(.rules)

Rule Base(.java)

Application(.java)

JAVACompiler

ByteCodes(.class)


JAVARuntime Environment

JEOPSInference Engine

• Mais simples de implementar

• Mais rápido de executar

33

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>

34

Definição das classes• Jogador, Time, Partida, ...

JEOPS - Exemplo de Utilização

class Time { private Jogador[] jogs; ...}

class Partida { private int etapa; private int tempo; ...}

class Jogador { private Time time; private int habilidade; ...}

class Goleiro extends Jogador {

...}

class Meia extends Jogador {

...}

class Atacante extends Jogador {

...}

35

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

}

36

Criação dos objetos

Execução do motor de inferência


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

base.run();

37

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

38

JEOPS - Outras Características

Resolução de conflitos• Mecanismo flexível de definição de políticas

Classes• LRUConflictSet • MRUConflictSet • NaturalConflictSet • OneShotConflictSet • PriorityConflictSet

39

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...

40

Estudo de Caso com o JEOPS:Definindo estratégias de combate

41

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


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


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?

Jogador


Cidade


UnidCombate


ataca(e:UnidCombate)anda(l:Localizacao)

Localizacao


dist(l:Localizacao): intmelhorUnidade(): UnidCombate


Repensando nas classes...

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...


Repensando nas regras...

Jogador


emPaz(j:Jogador):bool

Cidade


UnidCombate



Localizacao


dist(l:Localizacao): intmelhorUnidade(): UnidCombatepodeSerAlcançada (u:UnidCombate): boolean



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);}


Repensando nas regras...

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!}


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

Jogador


emPaz(j:Jogador):bool

Cidade


UnidCombate

- nome: String- dono: Jogador- movim: int- local: Localizacao- ataque: int- defesa: int


Localizacao


dist(l:Localizacao): intmelhorUnidade(): UnidCombate




Ou ainda eu posso criar uma nova cidade...rule criaCidade { declarations Jogador eu; Settler meuExerc; 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); }

A decisão de criar uma cidade pode requerer uma base de conhecimento à parte

Localizacao


dist(l:Localizacao): inthaComidaPerto() : booleanhaCidadePerto() : booleanhaOceanoPerto() : boolean




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

}

54

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)

55

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?


56

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}

57

Desvantagem: modificação • Detecção da modificação de objetos devido ao

encapsulamento• Modificação direta e transitiva....


58

Referências

• Masini et al - Object Oriented Languages (Cap 9)• Proceedings of the OOPSLA’94 - workshop on Embedded Object-

Oriented Production Systems• Pachet F. - On the embeddability of production rules in object-

oriented 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.

Documents

Programação de Agentes em uma Linguagem Orientada a Objetos: a Solução EOOPS