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:


CmAmi: CmrMmj:


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


CnAni: CnqMnj:


CpApi: CpkMpj:


CmAmi: CmrMmj:


Base de Objetos

OpiApi: Opk

OmjAmi: Omr

OpmkAmi: Omr

Substituir métodos procedimentaispor bases de regras


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


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

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

}

Representação do conhecimento híbrida com regras e objetos André Novaes, Bruno Jamir Jacques...

Documents

Transcript of Representação do conhecimento híbrida com regras e objetos André Novaes, Bruno Jamir Jacques...