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

Apresentação em tema: "Abordagens de programação EOOPS: Integração objetos-regras de produção"— Transcrição da apresentação:

1 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

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 AIOL (AI-Oriented Language) Reasoning Mechanism

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 Host

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 Reasoning Mechanism OO Mechanisms

9 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 Host Language AI AIOL Reasoning Mechanism

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 AI AI - - Oriented Oriented Translator Language Language Reasoning Mechanism

11 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

12 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

13 EOOPS Embedded Object-Oriented Production Systems

14 Lembrete sobre sistemas de produção
Conjunto de Base de regras de produção Memória de trabalho (base de fatos) Conjunto de conflitos (das regras disparáveis) Passos (encadeamento progressivo) Unificação da condições com os fatos Resolução de conflitos entre regras ativas Execução das ações da regra

15 Lembrete sobre sistemas de produção
Base de fatos Pai(João, José) Pai(José, Marcos) Base de Regras  p1, p2, p3: Pai(p1,p2)  Pai(p2,p3)  Avo(p1,p3) Motor de Inferência Avo(João, Marcos) unificação

16 Lembrete sobre sistemas de produção
Base de Regras unificação Conjunto de Conflito Base de Fatos resolução de conflitos Regra Ciclo Novos Fatos execução Obs: para não ter de re-testar a cada ciclo, só testa os fatos modificados (retirados, adicionados)

17 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) Pai(João, José) Pai(José, Marcos)  p1, p2, p3: Pai(p1,p2)  Pai(p2,p3)  Avo(p1,p3) Nome: Marcos José João pai Pessoa 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 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, ...

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 Sistema Ling. Progr. C++ Smalltalk 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 Aplicações Sites
COOL (CLIPS Object-Oriented Language) Foi uma linguagem utilizada bem difundida (> usuários) Aplicações medicina, multiagentes, helpdesk, aplicações aeroespaciais, etc. Sites

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

25 Regras NéOpus Toda classe Smalltalk Regras com sintaxe de Smalltalk
Object subclass: #Pessoa instanceVariableNames: ‘nome pai’! 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.!

26 NéOpus ViraCasaca | Pessoa p| (p timePreferido) nome = “Santa Cruz”.
Actions | Time bom | bom := Time new. bom nome: “Sport”. p timePreferido: bom. P modified. Pessoa nome idade timePreferido(): Time timePreferifo(t : Time) time Time nome nome(): String nome(n : String)

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

28 Regras JESS (CLIPS para Java)
Pode usar classes Java, com restrições Regras com sintaxe própria (lisp-like) class Pessoa { private String nome; private Pessoa pai; ... } (defclass Pessoa Pessoa) (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) )

29 JEOPS Java Embedded Object Production System
Made in Cin (1997/2-2000/1)

30 JEOPS - Princípios Java Uniformidade total de integração
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 Knowledge Base Agente assert run objects flush
Conjunto de Conflito Rete Gera entradas Consulta - ---- -- Knowledge Base Base de Objetos Base Interna de Regras Base de Conhecimentos Assert = insere objetos na base de objetos Objects = recupera objetos da base de objetos Flush = limpa base de fatos

32 Esquema de Compilação Mais simples de implentar
JEOPS JEOPS JEOPS JEOPS Compilation Environment Compilation Environment Compilation Environment Compilation Environment Rule Base Rule Base JEOPS JEOPS Rule Base Rule Base (.rules) (.rules) Rule Pre Rule Pre - - Compiler Compiler (.java) (.java) JEOPS JEOPS Esquema de Compilação Engine Engine Application Application JAVA JAVA (.java) (.java) Compiler Compiler Mais simples de implentar Mais rápido de executar ByteCodes ByteCodes (.class) (.class) JAVA JEOPS JEOPS JEOPS Runtime Environment Runtime Environment Runtime Environment Runtime Environment JEOPS JEOPS Inference Inference Engine Engine

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

35 JEOPS - Exemplo de Utilização
Criação das regras rule Retranca { declarations Partida p; Jogador a; 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 JEOPS - Exemplo de Utilização
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 Agentes x Base de Conhecimento?
Agentes estão dentro da base de objetos Por exemplo jogadores estão dentro de uma base sobre jogar futebol... É como se fosse uma 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}

40 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. Deixar a base de conhecimentos trabalhar... 5. Escolher estratégia de resolução de conflito

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

42 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

43 JEOPS - Estudo de Caso Pensando nas classes... Jogador Cidade
UnidCombate Localizacao - nome: String - pais: String - nome: String - dono: Jogador - local: Localizacao - nome: String - dono: Jogador - movim: int - local: Localizacao ataca(e: UnidCombate) anda(l: Localizacao) - linha: int - coluna: int dist(l:Localizacao): int

44 JEOPS - Estudo de Caso Pensando nas regras...
rule defendeCidade { // Se houver algum inimigo por perto, declarations // é 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?

45 JEOPS - Estudo de Caso Repensando nas classes... Jogador Cidade
UnidCombate Localizacao - nome: String - pais: String - nome: String - dono: Jogador - local: Localizacao - nome: String - dono: Jogador - movim: int - local: Localizacao ataca(e:UnidCombate) anda(l:Localizacao) - linha: int - coluna: int dist(l:Localizacao): int melhorUnidade(): UnidCombate

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

47 JEOPS - Estudo de Caso Repensando nas classes... Jogador Cidade
UnidCombate Localizacao - nome: String - pais: String emPaz(j:Jogador):bool - nome: String - dono: Jogador - local: Localizacao - nome: String - dono: Jogador - movim: int - local: Localizacao ataca(e:UnidCombate) anda(l:Localizacao) - linha: int - coluna: int dist(l:Localizacao): int melhorUnidade(): UnidCombate podeSerAlcançada (u:UnidCombate): boolean

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

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

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

51 JEOPS - Estudo de Caso Repensando nas classes... Jogador Cidade
UnidCombate Localizacao - nome: String - pais: String emPaz(j:Jogador):bool - nome: String - dono: Jogador - local: Localizacao - nome: String - dono: Jogador - movim: int - local: Localizacao - ataque: int - defesa: int ataca(e:UnidCombate) anda(l:Localizacao) - linha: int - coluna: int dist(l:Localizacao): int melhorUnidade(): UnidCombate

52 JEOPS - Estudo de Caso Ou ainda eu posso criar uma nova cidade...
A decisão de criar uma cidade pode requerer uma base de conhecimento à parte 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); }

53 JEOPS - Estudo de Caso Repensando nas classes... Localizacao
- linha: int - coluna: int dist(l:Localizacao): int haComidaPerto() : boolean haCidadePerto() : boolean haOceanoPerto() : boolean

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

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

56 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? Parte ação das regras: agenda ou executa? Agente dentro e fora da KB?

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

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