Representação do conhecimento híbrida com regras e objetos André Novaes, Bruno Jamir Jacques...
-
Upload
ricardo-arruda-amaro -
Category
Documents
-
view
220 -
download
3
Transcript of Representação do conhecimento híbrida com regras e objetos André Novaes, Bruno Jamir Jacques...
Representação do conhecimento híbrida com regras e objetos
André Novaes, Bruno JamirJacques Robin
CIn-UFPE
Roteiro
Motivação da integração regras + objetos Variedades de integração JEOPS: um sistema de produção embutido em Java Flora: uma extensão orientada a objetos de Prolog Comparação JEOPS X Flora
FRC híbridos regras+objetos: motivação
Pontos fortes fortes dos sistemas baseado em regras fornece com built-in dedução lógica da 1a ordem com negação por falha um mecanismo de inferência
poderoso e o mais versátil de todos
com semântica formal que pode também servir de
base para implementação de outros mecanismos como abdução, indução, planejamento, raciocínio não monótono
usam regras que: são intuitivas e modulares preservam a verdade
(detachment) pode ser adquiridas por
aprendizagem de máquina
Pontos fracosfracos dos sistemas baseado em regras codificação não intuitiva do conhecimento terminológico e procedimental
quase nenhuma facilidade para estruturação de entidades complexas
limitações das ferramentas e metodologias de desenvolvimento distribuído em larga escala
pouca padronização poucos serviços computacionais não de IA implementados com regras
interoperabilidade limitada com outras linguagens
FRC híbridos regras+objetos: motivação
Pontos fortesfortes dos sistemas orientado a objetos como FRC codificação intuitiva do conhecimento terminológico e procedimental
facilidade para estruturação de entidades complexas
ferramentas e metodologias de desenvolvimento distribuído em larga escala consolidadas e muito difundidas
API para os mais variados serviços computacionais e linguagens
ênfase na padronização, interoperabilidade e reuso
Pontos fracosfracos dos sistemas orientado a objetos como FRC sem máquina de inferência built-in de propósito geral
qualquer mecanismo de inferência além da herança deve ser implementado de zero
parte comportamental codificada de maneira procedimental
ausência da técnicas de aprendizagem de máquina de classes e objetos
sem semântica formal
FRC híbridos regras+objetos:almejar “o melhor dos 2 mundos”
Requisitos Raciocino:Requisitos Raciocino:• Linguagem declarativa• Predicados com variáveis lógicas• Dedução automática• Semântica formal• Completude computacional
Requisitos OO:Requisitos OO:• Identidade de objetos• Objetos complexos• Classes • Encapsulamento• Herança• Sobrescrita e sobrecarga
FRC Híbrido Regras + FRC Híbrido Regras + ObjetosObjetos
Formalismos de Representação do Conhecimento Híbridos Regras + ObjetosRegras + Objetos
Inferência Baseadaem Regras
Inferência Baseadaem Modelagem
Orientada a Objetos
Sistemas de Produção
Programação em Lógica
Sistemas de ProduçãoEmbutidos em Linguagem
Orientada a ObjetosEOOPS
Programação em LógicaOrientada a Objetos
OOLP
Programação emLógica Descritiva
Sistemas de Produçãocom Frames
Frames
LógicasDescritivas
Linguagem deProgramação
Orientadaa Objetos
Formalismos de Representação de Conhecimento Escaláveis e PersistentesEscaláveis e Persistentes
Híbridos Regras + ObjetosInferência Baseada
em Regras
Sistemas de Produção
Programação em Lógica
BDAtivos
OO
BDDedutivos
OODOOD
Serviços deBanco de Dados
BDRelacional
BDOrientadoa Objetos
BDAtivos
BDDedutivos
BDObjeto-
Relacional
Regras e objetos: como
integrar?Sistema Baseado em Regras
Base de Regrasf1(...,X,...)...fn(...,X,...)
f0(...,X,...)
Base de Fatos
f1(...,a,...) fn(...,a,...) f0(...,a,...)f1(...,b,...) fn(...,c,...) f0(...,d,...)
Sistema Orientado a Objetos
Hierarquia de Classes
CnAni: CnqMnj:
{while ... do ... if ... then ... else ... }
CpApi: CpkMpj:
{while ... do ... if ... then ... else ... }
CmAmi: CmrMmj:
{while ... do ... if ... then ... else ... }
Base de Objetos
OpiApi: Opk
OmjAmi: Omr
OpmkAmi: Omr
Integrar regras com objetos: alternativas sintáticas
Sistema híbrido = sistema orientado a objetos no qual: métodos procedimentais das classes foram substituídos por bases de regras encapsuladas
Sistema híbrido = sistema baseado em regras no qual: instâncias de termos lógicos na base de fatos foram substituídos por objetos instâncias de uma hierarquia de classes
termos lógicos nas premissas e conclusões das regras foram substituídos por padrões de objetos com variáveis lógicas no lugar de: nome de objetos e valores de atributos possivelmente também nome de classe e atributos
Substituirbase de fatos por base de objetos
Base de Regrasf1(...,X,...)...fn(...,X,...)
f0(...,X,...)
Hierarquia de Classes
CnAni: CnqMnj:
{while ... do ... if ... then ... else ... }
CpApi: CpkMpj:
{while ... do ... if ... then ... else ... }
CmAmi: CmrMmj:
{while ... do ... if ... then ... else ... }
Base de Objetos
OpiApi: Opk
OmjAmi: Omr
OpmkAmi: Omr
Substituir métodos procedimentaispor bases de regras
Hierarquia de Classes
CnAni: CnqMnj:
CpApi: CpkMpj:
CmAmi: CmrMmj:
fpj1(...,X,...)...fpjn(...,X,...) fpn0(...,X,...)
fnj1(...,X,...)...fnjn(...,X,...) fnn0(...,X,...)
fmj1(...,X,...)...fmjn(...,X,...) fmn0(...,X,...)
Base de Objetos
OpiApi: Opk
OmjAmi: Omr
OpmkAmi: Omr
Integrar regras com objetos: alternativas de implementação
Camada de RegrasLinguagem Hóspede Orientada a Objetos
CamadaOrientada a Objetos
Linguagem Hóspede Lógica
Linguagem de RegrasOrientada a Objetos
Linguagem de Implementação Orientada a Objetos
Linguagem de RegrasOrientada a Objetos
Linguagem deImplementação Lógica
LoPiX, SiLRI
CLIPS, RAL/C++, NéOpus, JESS, JEOPS Flora, Logtalk
Sistemas de produção orientados a objetos EOOPS
CLIPS
RAL/C++
NéOpus
JESS
JEOPS
Sistema Ling.Progr.
C++
C++
Smalltalk
Java
Java
Unif.Integr.
-
+/-
+
-
+
Serviços
-
+
-
+/-
+
Eficiência
+/-
+
+/-
+/-
+/-
Encad. Resol.Conflitos
-
-
+
-
+/-
Regras JESS
Pode usar classes Java, com restrições
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))
class Pessoa { private String nome; private Pessoa pai; ...}(defclass Pessoa Pessoa)
JEOPS: Java Embedded Object-Oriented Production System
Sistema desenvolvido no CIn-UFPE Base de conhecimento JEOPS:
Parte intencional terminológica: definições de classes Java Parte extensional: definições de objetos Java Parte intencional dedutiva: regras de produção onde
cada premissa invoca algum método Java booleanobooleano definido em uma classe da parte terminológica da base
cada ação invoca um método Java arbitrário definido em uma classe da parte terminológica da base
Base de fato substituída por base de objetos Fases de casamento de padrão e de execução de Fases de casamento de padrão e de execução de
ações incluem herançaações incluem herança Fase de resolução de conflito não modificada (mas
poderia se aproveitar da herança)
Lembrete sobre sistemas de produção
Base de FatosBase de Regras unificação
Conjunto de Conflito
resoluçãode conflitos
Regra
Novos Fatos
execução
Ciclo
Obs: para não ter de re-testar a cada ciclo, só testa os fatos modificados (retirados, adicionados)
Mudança de paradigma Fatos: Termos Lógicos Objetos Predicados: Símbolos Lógicos Métodos Booleanos Java Casamento estrutural Casamento comportamental (pertinência a classes + veracidade dos predicados)
Casamento de padrão comportamental
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
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>
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 fatos
Esquemade Compilação
JEOPSCompilation Environment
JEOPSCompilation Environment
JEOPSEngine
JEOPSRule Pre -Compiler
Rule Base(.rules)
Rule Base(.java)
Application(.java)
JAVACompiler
ByteCodes(.class)
JEOPSRuntime Environment
JEOPSRuntime Environment
JEOPSInference Engine
JEOPSCompilation Environment
JEOPSCompilation Environment
JEOPSEngine
JEOPSRule Pre -Compiler
Rule Base(.rules)
Rule Base(.java)
Application(.java)
JAVACompiler
ByteCodes(.class)
JEOPSRuntime Environment
JAVARuntime Environment
JEOPSInference Engine
• Mais simples de implementar
• Mais rápido de executar
Exemplo ilustrativo: base de conhecimento de planejamento de safári Motivação:
Exemplos clássicos não ficam naturais se resolvidos utilizando Regras + OO Problema das rainhas Resolução do fibonacci
Exemplo do Wumpus não ilustra bem o problema Objetos simples sem herança Sem cálculos matemáticos Sem casamento de padrões por classes
Solução Modelagem de um novo problema com Vários objetos Regras com casamento de padrões por tipos Herança
Problema: sem profundidade de associação de objetos
Exemplo ilustrativo: base de conhecimento de planejamento de safári Organizando uma expedição de safári
Objetivos: Qual animal será a caça? Em que ambiente será realizado o safári?
Veículo: Aquático? Terrestre?
Tripulação: Quantos guias serão necessários? Quantos caçadores? Quantos motoristas?
Armas: Armas de fogo? Armas brancas?
Base de conhecimento de planejamento de safári: Ontologia UML
Como implementar o safári em JEOPS?
Diagrama de ClassesClasses UML Classes JavaRestrições OCL regras de produção OO
Encadeamento de regrasDetalhamento dos Casos de Uso + Diagrama de seqüências
Comportamento do fluxo e chamadas à base de conhecimento
Métodos numéricosMétodos nas classes Java
Passos de desenvolvimento de uma base de conhecimento JEOPS
1. Definir as classesAtributos e métodos
2. Definir as regrasInteração entre os objetos da base
3. Voltar ao passo 14. Deixar a base de conhecimentos trabalhar...5. Escolher estratégia de resolução de conflito
Exemplo de uso: Safári Definição das classes
Arma, ArmaFogo, GrupoSafari, ...Abstract class Arma { private int preco; private String nome; ...}
class ArmaFogo extends Arma { private int calibre; private int qtdMunicao; private int precoMunicao; ...}
class GrupoSafari{public Vector tripulantes;public Vector pertences;public Vector veiculos;public int financiamento;public int numeroMaximoTripulantes;
...}
Exemplo de uso: Safári
Criação das regras
rule ContrataGuia{ declarations GrupoSafari g; Guia guia; localdecl conditions g.getTripulantes().size() < g.getNumeroMaximoTripulantes(); g.getLocal().instanceOf(LocalTerrestre); ((LocalTerrestre) g.getLocal).getAberto() == false; g.getNumeroGuias == 0; actions g.putTripulante(guia); modified(g);}
Exemplo de uso: Safári
Criação dos objetosRegrasSafari base = new RegrasSafari();
base.assert(new AnimalAquatico(“baleia”, "grande", false));base.assert(new LocalAquaticoTerrestre("Pântano", "raso", false));base.assert(new VeiculoAquatico("Lancha", 8, new Vector("baixa",
"media"));...
Execução do motor de inferênciabase.run();
JEOPS: características interessantes
Pré-compilação de regras Regras convertidas em classes Java
Extensão de Rete para objetos complexos com herançaAlgoritmo eficiente de casamento de padrão entre fatos e premissa de regra
Estratégias built-in de resolução de conflitos LRUConflictSet MRUConflictSet NaturalConflictSet OneShotConflictSet PriorityConflictSet
KEOPS: Versão J2ME para rodar em dispositivos móveis Usado para implementar inteligência embutidos em jogos para celulares
JEOPS: aplicações práticas
Agentes de administração de rede Jogos interativos Recuperação de informação na web Música computacional
Flora = Frame Logic + HiLog + Transaction Logic + XSB
Prolog tabelado XSB
FloraFlora HiLogTransaction LogicFrame Logic
• Organização do conhecimento em hierarquia de classes• Representação de conhecimento taxonômico• Herança múltipla e dinâmica• Uso de processos de desenvolvimento OO
• Terminação garantida em muito mais casos• Cache se sub-provas • Negação por falha com semântica declarativa bem fundamentada
Compilador Flora
• Atualizações na base de fatos• Integrado ao backtrack• Representação de conhecimento procedimental • Sintaxe de ordem
superior • Semântica da 1a ordem• Meta-programação• Meta-consultas ao esquema
Exemplo de programa FloraClasses:
veiculo[capacidade=>integer].veiculoAquatico::veiculo[profundidade=>>string].
armaFogo::arma[calibre *=> integer,qtdMunicao *=> integer, precoTotal(integer)*=>integer
].
arma[preco*=>integer, precoMunicao(10)->8, precoMunicao(12)->9].
rifle::armaFogo[calibre*->12,preco*->500].
Instâncias:
baleia:animalAquatico[porte->grande,perigoso->nao].bote:veiculoAquatico[profundidade->>baixa].lancha:veiculoAquatico[profundidade->>{baixa,media}].
Exemplo de programa FloraRegras
A[precoTotal*->P] :- A::armaBranca[preco*->P].
X:grupo[armas->>{arpao}] :- X:grupo[animal->baleia].
X[veiculos->>{V}] :- comprouVeiculo, X:grupo.local:localAquatico[profundidade->P],V:veiculoAquatico[profundidade->>P], btinsert{comprouVeiculo}.
A[precoTotal(Q)*->T] :- A::armaFogo[preco*->P,calibre*->C], arma[precoMunicao(C)->PC], T is PC*Q+P.
X[armas->>{rifle_ld1:rifle_longa_dist[qtdMunicao->10],rifle1:rifle[qtdMunicao->20]}] :-
X:grupo[animal->_A:animalTerrestre[porte->T]], T \= pequeno, Soma is rifle_longa_dist!precoTotal(10) + rifle!precoTotal(20), precoArmasMaximo(PM), Soma < PM.
Exemplo de programa FloraConsultas
g1:grupo[animal->leao].g2:grupo[animal->baleia].
?- G:grupo[armas->>R[qtdMunicao->Y]].
G = g1 R = rifle1 Y = 20G = g1 R = rifle_ld1 Y = 10
?- G:grupo[armas->>R:armaBranca].
G = g2 R = arpao
?- G :grupo[animal->A], tnot A[porte->medio].
G = g2 A = baleia
Sintaxec1::c2 Herança de classes animalTerrestre::animalo1:c1 Instanciação de Objeto leao:animalTerrestrec[m=>t] Assinatura de Métodos
Univaloradosgrupo[animal=>animal].
c[m=>>t] Assinatura de Métodos Multivalorados
grupo[armas=>>arma].
c[m->v] Métodos Univalorados grupo[animal->leao].c[m->>{v1,...,vn}]
Métodos Multivalorados grupo[armas->>{rifle1,rifle2}].
*-> *->> *=> *=>>
Métodos que são herdados pelas subclasses/instancias
rifle::armaFogo[calibre*->12]. armaFogo::arma[calibre *=> integer].
Agrupando: veiculoAquatico::veiculo[profundidade=>integer,profundidade*->media].
rifle:armaFogo[calibre->12,preco->500].
g1:grupo[animal->X[porte->medio]].
Legenda: c: classe, o: objeto, m: método, v: valor, p: parâmetro
Sintaxe
head :-p1,...pn Regra X:grupo[armas->>{arpao}] :- X:grupo[animal->baleia].
?- p1,...pn Conculta
tnot Negação tabelada X[voa->sim] :- X:ave, tnot X:pinguim.
\+ Negação não tabelada
p(X) :- \+ q(X).
X \= Z Diferença X[irmao->Y] :- X[pai->Z], Y[pai->Z], X \= Z.
c1.m1, c1!m1(m. Herdado)
Expressão de caminho –método univalorado
?- g1.animal[porte->X]?- g1[animal->A], A[porte->X]
o1..m2, o1!!m2 (m.herdado)
Expressão de caminho -método multivalorado
?- g1..arma[preco->X]?- g1[arma->>A], A[preco->X]
; ou ?- a:[porte->medio] ; a:[porte->grande]
Sintaxe Predicados como em Prolog:
g1:grupo[armas->>{a1,a2}]. arma_grupo(g1,a1).arma_grupo(g1,a2).
Permite aninhar objetos em predicados
arma_grupo(a1:arma[preco->100]).
Não permite aninhar predicados dentro de objetos
Consultas Flora X SQL
SQL - Classes
create table animal ( id_animal varchar(...), porte varchar(...));create table grupo ( id_grupo varchar(...), id_animal varchar(...),);
SQL - Instanciasinsert into grupo values(...)insert into animal values(...)
SQL - Consultasselect animal.porte as Xfrom grupo, animalwhere grupo.id_grupo = g1 and grupo.id_animal = animal.id_animal
Flora ?- g1:grupo.animal[porte->X]
Herançaelefante[cor*->cinza].clyde:elefante[cor->branca].?- clyde[cor->X].
X = branca
d[m*->e].d::b.b[m*->c].a:b.a:d :- a[m->c].
?- X[m*->Y].X = b Y = cX = d Y = e
?- X[m->Y].X = a Y = cX = a Y = e
HiLog
Sintaxe de alto nivel Semântica de primeira ordem Podem aparecer em qualquer lugar onde um simbolo de função
apareça Ex: p(f(x))(a,b,c) , g(f)(g)[m(h(x))->b] Variaveis podem aparecer em qualquer parte
Permite meta-programaçãoTodos os metodos univalorados da classe c1:
? - c1[M=>T]Todas as subclasses de classes com o metodo m:
? - X::c1[m=>_] Traduzido por predicados apply/N
closure(R) (X,Y) apply(apply(closure,R),X,Y)
Transaction Logic Permite atualização da base de fatos Representação de conchecimento procedimental Sintaxe: operacao{literais[|query]} Non-Backtrackable update
Operações desfeitas quando há backtrackinsert,insertall,delete,deleteall,erase,eraseall
Backtrackable updateOperações persistem após backtrack btinsert,btinsertall,btdelete,btdeleteall,bterase,bteraseall
Problemas com tabelamento
Transaction Logictransfer(Amt,Acct1,Acct2) :-
withdrawn(Amt,Acct1), deposit(Amt,Acct2).withdrawn(Amt,Acct) :-
balance(Acct,Bal), Bal >= Amt, Bal2 is Bal - Amt ,change_balance(Acct,Bal,Bal2).deposit(Amt,Acct) :-
balance(Acct,Bal), Bal2 is Bal + Amt ,change_balance(Acct,Bal,Bal2).
change_balance(Acct,Bal1,Bal2) :- ...
?- insert{balance(c1,100)}, insert{balance(c2,0)}, insert{balance(c3,0)}.?- transfer(100,c1,c2),transfer(100,c1,c3).?- balance(c1,X).
Com backtrack
change_balance(Acct,Bal1,Bal2) :- btdelete{balance(Acct,Bal1)}, btinsert{balance(Acct,Bal2)}.
X = 100.
Sem backtrack(como em prolog)
change_balance(Acct,Bal1,Bal2) :- delete{balance(Acct,Bal1)}, insert{balance(Acct,Bal2)}.
X = 0.
F-Logic: aplicações práticas Engenharia de software:
especificação formal executável orientada a objetos Inteligência artificial:
representação do conhecimento por meio de regras e hierarquias conceituais
Banco de dados:BD dedutivas orientada a objetosintegração de dados
integração de codificações integração de esquemas integração de BD com modelos de dados diferentes
Web semântica:Agentes inteligentes de processamento de informação na webDedução automática sobre documentos, objetos e dados na web
Implementações de F-Logic Flora:
F-Logic + HiLog + Transaction Logic
Compilador F-Logic para XSB Prolog implementado em Prolog
Domínio público, open source Stony Brook University, New York
LoPiX: F-Logic + XPath + XML Implementado em C++, no
entanto sem API C++ Domínio público, executável University of Freiburg, Alemanha
SiRLI: F-Logic com extensões lógicas
(quantificadores existenciais, conectivas)
Implementado em Java Comercial, ontoprise.com
TRIPLEF-Logic + RDFCompilador para FloraDomínio públicoStanford/DFKI
FloracleF-Logic + HiLog + Transaction Logic
Compilador para Oracle9iEm desenvolvimento no CIn por mim!
Substituir métodos procedimentaispor bases de regras: exemplo
(Linguagem Pluto)
class person [ address => string; spouse => person; public mary(person); public divorce(); X[mary(Y)] :- X[not spouse -> Z, gender ->
G], Y[not spouse -> Z1], not gender -> G], ins X[spouse -> Y], ins Y[spouse -> X]; X[divorce] :- del X[spouse -> Y], del Y[spouse -> X]]
class employee isa person[ worksIn => dept; salary => integer; public raise(integer); X[raise(Y)] :- S2 is S1 + S2 * Y, del X[sakary ->S1], ins X[salary -> S2]]
class dept.
tom:employee[worksIn -> cpsc, spouse -> pat,
salary -> 20000].cpsc:dept.pat:person[spouse -> tom].
Substituir fatos por objetos: exemplo (Linguagem Flora)
person[address => string, spouse => person, mary(person) => void, divorce => void]. employee::person[worksIn => dept, salary => integer, raise(integer) => void].
X:person[mary(Y:person[gender -> Gy]), gender -> Gx] :- not X.spouse, not Y.spouse, Gx =/ Gy, ins(X[spouse -> Y]), ins(Y[spouse -> X]).
X:person[divorce,spouse -> Y[spouse -> X]] :- del(X[spouse -> Y]), del(Y[spouse -> X]).
X:employee[raise(R:integer), salary -> S] :- S1 is S + R, del(X[salary -> S]), ins(X[salary -> S1]).
tom:employee[worksIn -> cpsc, spouse -> pat, salary -> 20000].cpsc:dept.pat:person[spouse -> tom].
Qual conhecimento codificar nas regras equal conhecimento codificar nos objetos?
Não existe metodologia estabelecida para fazer tal escolha Com a experiência da codificação de bases de conhecimento
em domínio diversos, o engenheiro do conhecimento desenvolve intuição para distinguir entre: conhecimento dedutivo x conhecimento terminológico conhecimento declarativo x conhecimento procedimental
Identificar critérios gerais e rigorosos para fazer essas distinções permanece um problema aberto de pesquisa
Conhecimento dedutivo melhor codificado com regras Conhecimento terminológico melhor codificado com hierarquia
de classes Conhecimento procedimental melhor codificado com métodos
Flora Programação em lógica OO Hospedado em PrologProlog tabelado Sem procedimentosSem procedimentos imperativos Sem encapsulamentoSem encapsulamento Unificação estruturalestrutural
incorporando herança Com semântica Com semântica formal Encadeamento regressivoregressivo Variáveis lógicas em qualquer
posição de estruturas de objetos ou classes
FracamenteFracamente tipada Generaliza modelos de dados
relacional, orientado a objetos e objeto-relacional
JEOPS Sistema de produção OO Hospedado em JavaJava Com procedimentosCom procedimentos imperativos Com encapsulamentoCom encapsulamento Casamento de padrões
comportamentalcomportamental incorporando herança
Sem semântica Sem semântica formal Encadeamento progressivoprogressivo Variáveis apenas em posição de
nome de objeto e valor de atributo
FortementeFortemente tipada
Flora x JEOPS
Vantagens de Flora Linguagem multiuso:
especificação formal executável programação banco de dados representação do conhecimento
Semântica formal bem definida Concisão do código Expressões de ordem superior
para meta-programação e consultas a esquema de BD
Prototipagem rápida de meta-interpretadores para: abdução, indução, resolução de restrições, planejamento e raciocínio bayesiano
Encadeamento regressivo natural para agentes deliberativos
Eficiência
Vantagens de JEOPS Incorporação imediata dos
milhares de serviços disponíveis via API Java
Fácil de aprendizagem para larga base de desenvolvedores Java
Encadeamento progressivo natural para agentes reativos
Flora x JEOPS
Flora x JEOPS: comparação para safáriarmaFogo::arma[calibre *=>
integer,qtdMunicao *=> integer, precoTotal(integer)*=>integer
].
public class ArmaFogo extends Arma{private int calibre;private int quantidadeMunicao;private int precoMunicao; public ArmaFogo(String nome, int preco, int calibre, int quantidadeMunicao,int precoMunicao){
super(nome, preco);... }
public void setCalibre(int calibre){...}public int getCalibre(){...}
...public int getPrecoTotal(){ ...}
...}
rifle::armaFogo[calibre*->12,preco*->500].
public class Rifle extends ArmaFogo{
public Rifle(String nome, int quantidadeMunicao,int precoMunicao){
super(nome, 500, 12, quantidadeMunicao, precoMunicao);
}}
Flora x JEOPS: comparação para safári
baleia:animalAquatico[ porte->grande, perigoso->nao].
lancha:veiculoAquatico[ profundidade-
>>{baixa,media}].
pantano:localAquatico, localTerrestre[ profundidade->baixa, aberto->nao].
AnimalAquatico baleia = new AnimalAquatico("grande", false);
VeiculoAquatico lancha = new VeiculoAquatico("Lancha", 8,
new Vector("baixa", "media")
);
LocalAquaticoTerrestre pantano = new LocalAquaticoTerrestre(
"Pântano", "raso", false);
Flora x JEOPS: comparação para safáriX[veiculos->>{V}] :-
comprouVeiculo,X:grupo.local:localAquatico[profundidade->P],V:veiculoAquatico[profundidade->>P], btinsert{comprouVeiculo}.
rule CompraVeiculoAquatico{declarationsGrupoSafari g;VeiculoAquatico embarcacao;conditionsg.getVeiculos().size()==0;g.getLocal().instanceOf(LocalAquatico); embarcacao.getProfundidades().contains(((LocalAquatico)g.getLocal()).getProfundidade());actionsg.putVeiculo(embarcacao);modified(g);
}
Flora x JEOPS: comparação para safári
A[precoTotal(Q)*->T] :- A::armaFogo[
preco*->P,calibre*->C
], arma[precoMunicao(C)->PC],T is PC*Q+P.
public int getPrecoTotal(){ int preco = 0;
preco = this.getPreco() + (this.getPrecoMunicao() * this.getQuantidadeMunicao());return preco;
}
Flora x JEOPS: comparação para safárigrupo1[armas->>R[qtdMunicao->Y]]
GrupoSafari grupo = New GrupoSafari(...);
...
Vector armas = grupo.getArmas(); Arma arma = null;
for(int i; i< armas.size(); i++) {arma = (Arma) armas.get(i); System.out.println(arma.toString());
}