Regras de Produção:o Motor de Inferência JESS

Regras de Produção: o Motor de Inferência JESS Prof. Fred Freitas CIn - UFPE

Componentes de um Motor de Inferência

Um formalismo lógico de Representação de Conhecimento

Ex: Lógica de Descrição, Frames , regras, etc.

Um método ou estratégia de resolução ou mecanismo de inferência para o formalismo

Regras de Produção

Representam conhecimento com pares condição-ação

Se condição (ou premissa ou antecedente ) ocorre

então ação ( resultado , conclusão ou conseqüente ) deverá ocorrer.

Regras de produção produzem novos fatos a partir dos fatos e regras da BC.

Esses novos fatos passam a fazer parte da BC

Regras de Produção

Formalismo mais simples, procedimental e popular

animal(x)^estimação(x)

^pequeno(x) => (assert(doméstico(x))

premissas conseqüente

Base de fatos e base de regras

animal(Rex),estimação(Rex),pequeno(Rex)

Mecanismo de inferência: São produzidos novos fatos instanciando fatos existentes nas regras (encadeamento para a frente)

Estratégia de controle: resolução de conflito

Sistemas de Produção

Fatos: x , y

Regras: x & y => assert(p)

Encadeamento para a frente ( Forward chaining )

Dados x e y, derive então p

OPS5, CLIPS, Jess

Orientado a dados: O sistema deriva todas as conclusões possíveis, mesmo se elas não ajudam a resolver o problema

Encadeamento para trás ( Backward chaining )

p é verdad? Então verificarei x e y.

Prolog

Módulos de Sistemas de Produção

Base de Regras ou memória permanente

regras se-então e fatos conhecidos

Memória de Trabalho ou temporária

percepções do agente, fatos iniciais e gerados a partir da BR pelo mecanismo de inferência

Mecanismo (motor) de Inferência

determina o método de raciocínio utilizado (progressivo ou regressivo)

Executa a busca com casamento (unificação)

resolve conflitos e executa ações.

Arquitetura de Sistemas de Produção

Funcionamento de um sistema de regras de produção

As regras seriam a memória duradoura

Os fatos seriam a memória de trabalho

Ao usarmos as regras sobre os fatos, são derivados novos fatos

O ciclo se repete até que não haja mais fatos a derivar

Conflito: várias regras podem ser disparadas ao mesmo tempo

Sistemas Especialistas Facts "Item #123 is expensive speakers" "Gold cables are expensive" "Bob is a customer" "Bob is buying item #123" Rules "Recommend appropriate cables when customers buy speakers" Inference Engine List of Actions to Take "Recommend that Bob buy gold cables." O problema é simples... [Friedman-Hill]

Sistemas Especialistas Facts Rules Inference Engine For every customer, for every item in their cart, if it is speakers, for every catalog item, if the cart item is the catalog item, if the catalog item is in some price category, for every catalog item, if it is a cable and it is in the same category, recommend that cable to that customer. List of Actions to Take "Recommend that Bob buy gold cables." ... Mas a solução é cara: O (RF P )

O Algoritmo Rete

Representa regras como dados

O compilador gera máquinas de estado a partir de regras

Novos fatos guiam a máquina de estado (orientado a dados)

O algoritmo lembra os estados antigos

Charles L. Forgy, Artificial Intelligence 19 (1982), 17-37.

O Algoritmo Rete Facts Rules Inference Engine When a customer picks out an item, if it is speakers, recommend the appropriate cables. List of Actions to Take "Recommend that Bob buy gold cables." ... o algoritmo Rete pode ser O(RF)

O Algoritmo Rete

x & y => assert(p)

x & y & z => assert(q)

x? y? x? y? z? p q “ rede de padrões" “ rede conjunta" 8 nós [Friedman-Hill]

O Algoritmo Rete

x & y => p

x & y & z => q

x? y? z? p q 6 nós Otimização 1: Compartilhamento da rede de padrões x & y => assert(p) x & y & z => assert(q)

O Algoritmo Rete

x & y => p

x & y & z => q

x? y? z? p q 5 nós Otimização 2: Compartilhamento na rede conjunta x & y => assert(p) x & y & z => assert(q)

Boas práticas: eficiência

Durante o projeto de regras, lembrar que elas são implementadas através de uma rede

Evitar predicados com atributos muito gerais e que variam com freqüência (ex: status);

Construir o lado das premissas como uma consulta eficiente de banco de dados, ou seja, contendo apenas predicados necessários ao disparo de regras.

Praticando

java jess.Main – inicia o motor

Dentro do Jess:

Comandos de vizualização:

(facts) – vê a base de fatos

(watch compilations) – vê o processo de compilação da base de regras na rede

(watch facts) – vê cada modificação na base de fatos

(watch activations) – vê cada ativação de regra

Quando a regra está pronta para ser disparada

(watch rules) – vê as regras sendo disparadas

(watch all) – todas as opções acima

(unwatch XXX) – para desabilitar as opções acima

Definindo fatos e regras

(assert <fato>) – põe um fato na base

Ex: (assert (pequeno fido))

(defrule <nome da regra>

<padrão de fato 1> Lado esquerdo da

... regra (LHS)

<padrão de fato n>

=>

<ação 1> Lado direito da

... regra (RHS)

<ação n>

)

Exemplos

Fido

(batch example/Diver1.clp)

(batch example/Diver2.clp)

Problemas de mergulho: DIVER1.CLP

Problemas de

mergulho mais

Detalhados:

DIVER2.CLP

A Linguagem das Regras

(defrule recommend-appropriate-cables

(customer (id ?id ) (cart ?cart))

(cart (id ?cart) (contents $?cnt))

(item (id ?s&:(member$ $?cnt ?s))

(is speaker)(price-category ?pc))

(not (item (id ?c&:(member$ $?cnt ?c))

(is cable)

(price-category ?pc))

=>

(printout t "You need to buy " ?pc

" cables." crlf))

[Friedman-Hill]

Pacotes (módulos) de Regras

Apesar de não queremos controlar o fluxo de processamento, às vezes precisamos de fases

Em manutenção de dispositivos eletrônicos, e.g., as fases de detecção, isolamento, conserto e funcionamento

Organizar regras em pacotes (módulos) que são ativados um por vez

Engenharia de conhecimento

Qualidades das Regras

São fáceis de compreender (legíveis) e de modificar

Independência e Localidade

Flexibilidade (Expressividade)

Genericidade

Portabilidade

Facilidade, simplicidade e fidelidade semântica

Alterabilidade - > código auto-alterável

Liberdade e gradualidade

Interoperabilidade de conhecimento

Vide slides das aulas de ontologias

Desvantagens

Há problemas eminentemente procedimentais

Eficiência

Fácil funcionamento

Efetividade

Fluxo de Controle

Controle de consistência

Sistemas de Produção Plugáveis

Antes: Dificuldade de integrar as linguagens lógicas – LISP e Prolog- com as outras

Solução adotada: Permitir inferência às linguagens imperativas (C, Java, ...)

Interoperabilidade, portabilidade e reuso

Motores de inferência “plugáveis”

CLIPS: Integração C-regras

"C” Language Integrated Production System ) [Giarratano & Riley 98]

Inclui uma linguagem interna, COOL (“C” Object Oriented Language ) que representa classes como frames

Características de frames : herança múltipla, atributos podem ser instâncias de outras classes, inferência direta, facetas, etc

JESS - Java Expert System Shell

Integra objetos Java e Java beans a regras

Projetado para servir à comunidade de orientação a objetos

Milhares de usuários

Frames e Herança em JESS

Herança

apenas herança simples

(deftemplate ANIMAL (slot color) (slot weight)) (deftemplate CAT extends ANIMAL (slot whisker-count)) ;;CAT has three slots: color, weight, and whisker-count (deftemplate box (slot location) (multislot contents)) (assert (box(location kitchen) (contents spatula sponge frying-pan)))

Instanciação

Manipulando JESS a partir de Java

Exemplo: alterando a base de fatos a partir de um código em um projeto Java

public void definaInstancia(String atomo, Object objeto) throws ReteException { Funcall f = new Funcall("definstance", rete); f.add(new Value(atomo, RU.ATOM)); f.add(new Value(objeto, RU.EXTERNAL_ADDRESS)); f.simpleExecute(f, rete.globalContext()); }

Integração com Java

new

Conversões de tipo

import

Chamadas a métodos ( Call )

get e set

Manipulação direta das propriedades de um Bean

try-catch, throw

Persistência, GUI, Beans, ...

Integração com Java

(import java.util.*)

; create a Vector, add entries

(bind ?v (new Vector))

(call ?v addElement "foo")

(call ?v addElement "bar")

; iterate over Vector and print entries

(bind ?e (call ?v elements)) ; retorna um

; Enumeration que tem metodo nextElement(),…

(while (call ?e hasMoreElements) do

(printout t (call ?e nextElement) crlf))

[Friedman-Hill]

Jess e Ontologias via Protégé

Integrados via plugin Protégé JessTab [Eriksson 2003]

Agora Jess passa a ter atributos que podem ser instâncias de outras classes como o CLIPS

Executável dentro do Protégé

De Jess, pode-se manipular Protégé e vice-versa

Achar as cidades paraibanas mais próximas (entre 5  )

Arara

João Pessoa

Esperança

Campina Grande

Pocinhos

Estilo de programar com regras

Na ontologia temos :

City

x,y,name

E aí, como achar???

1º. Calcular as distâncias

Função (distância euclidiana):

(deffunction fdist (?x1 ?y1 ?x2 ?y2)

(return (sqrt (+

(** (- ?x1 ?x2) 2)

(** (- ?y1 ?y2) 2)))))

1º. Calcular as distâncias

(defrule dist

(object (is-a City) (OBJECT ?o1) (name ?n1) (x ?x1) (y ?y1))

(object (is-a City) (OBJECT ?o2&~?o1) (name ?n2) (x ?x2) (y ?y2))

(not (object (distance (city1 ?o1) (city2 ?o2))))

(not (object (distance (city1 ?o2) (city2 ?o1))))

=> (make-instance (str-cat ?n1 ?n2) of distance (city1 ?o1) (city2 ?o2) (value (fdist ?x1 ?y1 ?x2 ?y2)) map))

3º Achar o menor

3.1. Criar o predicado menor

(defrule first-menor

(not (closer ?))

(object (distance (city1 ?o1) (city2 ?o2) (OBJECT ?o)))

=> (printout t "a menor distancia agora entre 2 cidades paraibanas é " (* 100 (slot-get ?o value)) " entre " (slot-get ?o1 name) " e " (slot-get ?o2 name))

(assert (closer ?o)))

3.2. Comparar distâncias com o menor

3º Achar o menor

(defrule menor

?f <- (closer ?oc)

(object (distance (city1 ?o1) (city2 ?o2) (OBJECT ?o&~?oc) (value ?v&:(< ?v (slot-get ?oc value)))))

=>(printout t "a menor distancia agora entre 2 cidades paraibanas é “ (* 100 (slot-get ?oc value)) " entre " (slot-get ?o1 name) " e " (slot-get ?o2 name) "." crlf)