Page1 DAS-5341: Sistema CLIPS Prof. Eduardo Camponogara.

DAS-5341: Sistema CLIPS

Prof. Eduardo Camponogara

Agenda• Introdução à prática de construção de

sistemas especialistas• Linguagem de construção de SE´s CLIPS

CLIPS• CLIPS é uma linguagem de construção de

sistemas especialistas, que suporta os seguintes paradigmas– Paradigma baseado em regras– Orientação a objetos– Paradigma procedural

• Vamos nos concentrar em sistemas especialistas baseados em regras

Sistemas Baseados em Regras• Sistemas baseados em regras:

– Lista de fatos• Contém os dados nos quais inferências

são derivadas– Base de conhecimento

• Contém todas as regras– Máquina de inferência

• Controle de execução

Entrando e Saindo do CLIPS• Exemplo:

CLIPS> (+ 3 4)7

• Saindo do CLIPS(exit)

Fatos em CLIPS• Um fragmento de informação é dito fato (fact)

em CLIPS– Fatos consistem em um nome de relação

(relation name) seguida de zero ou mais entradas (slots) e seus valores associados

Inserindo Fatos• Inserindo fatos:

CLIPS> (person (name “John Q. Public”)(age 23)(eye-color brown)(hair-color black))

• Relation-name: person• O fato tem quatro slots:

– O valor do slot name é: “John Q. Public”

Construtor de Fatos• Antes de inserir um fato, temos que

definir a relação:

(deftemplate <relation-name> [<optional-comment>]

<slot-definition> )

<slot-definition> ::= (slot <slot-name>) | (slot <slot-name>) (slot <slot-name>)

Multifield Slots• Slots com mais de um campo podem ser

especificados com a palavra-chave multislot na entrada de deftemplate, podendo ter zero ou mais campos

• Sintaxe:(person (name John Q. Public) (age 23) (eye-color blue) (hair-color brown))

• A diretiva acima seria ilegal se name fosse um slot simples.

Fatos Ordenados• Exemplo:

(number-list 7 9 3 4 20)

• é equivalente a

(deftemplate number-list (multislot values))

(number-list (values 7 9 3 4 20))

Inserindo e Removendo Fatos• Fatos representam informações que podem ser

adicionadas e eliminadas da lista de fatos (fact list)• Fatos podem ser inseridos usando o comando

assertCLIPS> (deftemplate person (slot name)

(slot age) (slot eye-color) (slot hair-color))

CLIPS> (assert (person (name “John Q. Public”)

(age 23) (eye-color blue) (hair-color brown)))

Lista de Fatos• Para inspecionar a lista de fatos basta

executar o comando (facts)CLIPS> (facts)

• Removendo fatos da lista. – Sintaxe: (retract <fact-index>)

Modificando/Duplicando Fatos• Sintaxe do comando de modificação:

(modify <fact-index> <slot-modifier>+)

• Exemplo:CLIPS> (modify 0 (age 24))CLIPS> (facts)

• Duplicando um fato:CLIPS> (duplicate 2 (name “Jack S.

Public”))CLIPS> (facts)

O Comando Watch• O comando watch pode ser útil para

depuração de programas. A sua sintaxe é:(watch <watch-item>)

• Onde <watch-item> pode assumir os valores: – facts, rules, activations, statistics,

computations, or all

O Construtor Deffacts• Grupos de fatos que representam o

conhecimento inicial podem ser definidos usando o construtor deffacts

• Sintaxe:(deffacts <deffacts-name> [<optional-

comment>] <facts>*)

O Construtor Deffacts• Exemplo:

(deffacts people “some people we know” (person (name “Jack S. Public”) (age

24) (eye-color blue) (hair-color black)) (person (name “Jane Q. Public”) (age

26) (eye-color brown) (hair-color

brown)))

Componentes de uma Regra• Para que um sistema especialista faça algo

útil, devemos ser capazes de alimentá-lo com regras, não apenas fatos

• Regras podem ser digitadas diretamente em CLIPS ou elas podem ser carregadas a partir de um arquivo criado por um editor de texto

Componentes de uma Regra• Como um exemplo, que tipos de fatos e regras

que podem surgir em um sistema de monitoramento e resposta a emergências?

Componentes de uma Regra• Como um exemplo, que tipos de fatos e regras

que podem surgir em um sistema de monitoramento e resposta a emergências?– Fogo e inundação seriam duas situações de

emergência

• O pseudo-código para uma possível regra seria:Se emergência é fogoEntão a resposta é ativar a circulação de

água

Componentes de uma Regra• A regra de emergência pode ser representada

pelo template abaixo

(deftemplate emergency (slot type))(deftemplate response (slot action))

onde type {fire, flood, power-outage}

e action {call firefighters}

Componentes de uma Regra• Eliminando todos os deftemplates e deffacts criados

anteriormenteCLIPS> clear

• Entrando a regra(defrule fire-emergency “Um exemplo de

regra” (emergency (type fire)) =>(assert (response (action activate-sprinkler- system))))

A Sintaxe de Defrule

(defrule <rule-name> [<comment>] <patterns>*; lado esquerdo da regra

=><actions>* ; lado direito da regra

Funcionamendo de CLIPS• CLIPS tenta casar os padrões das regras com os

fatos que aparecem na lista de fatos

– Se todos os padrões da regra casam com os fatos, então a regra está ativa e é colocada na agenda

– Agenda é a coleção de todas as regras ativas

– A última parte da regra (o que segue o símbolo ‘=>’) é uma lista de ações que serão executadas caso a regra seja disparada

Funcionamendo de CLIPS• Quando há múltiplas regras na agenda, CLIPS

automaticamente determina qual regra é a mais apropriada para ser disparada

– CLIPS ordena as regras da agenda em ordem decrescente de prioridade e dispara a regra de maior prioridade

Execução e Agenda• O comando “run” faz CLIPS rodar um

programa

• A sintaxe é:(run [<limits>])

• Se <limits> não é dado, então as regras serão disparadas até que a agenda fique vazia

Inspecionando a AgendaCLIPS> (reset)CLIPS> (assert (emergency (type fire)))CLIPS> (agenda)

– (Executar código diretamente com CLIPS)

Refração• Regras em CLIPS tem a propriedade de

refração (refraction) que significa que uma regra não será disparada mais do que uma vez para um conjunto específico de fatos– Sem refração, um sistema especialista irá

entrar em laços triviais

• O comando refresh pode ser usado para fazer com que uma regra dispare outra vez

Comandos Manipuladores• Listando construtores

CLIPS> (list-defrules)CLIPS> (list-deftemplates)CLPIS> (list-deffacts)

• Monstrando o conteúdo de rules, templates e factsCLIPS> (ppdefrule <define-name>)CLIPS> (ppdeftemplate <deftemplate-

name>)CLIPS> (ppdeffact <deffacts-name>)

Comandos Manipuladores• Deletando um certo construtor

• Sintaxe:(undeffacts <deffacts-name>)(undeftemplate <deftemplate-name>)(undefrule <defrule-name>)

O Comando de Impressão• A sintaxe do comando printout e:

(printout <logical-name> <print-items>*)<logical-name> se refere ao destino da saída

• Example:(defrule fire-emergency (emergency (type fire))=>

(printout t “Activate the sprinkler system” crlf))

Usando Múltiplas Regras• Sistemas especialistas práticos podem

consistir em centenas ou milhares de regras

– Além da regra fire-emergency, o sistema especialista monitor da planta industrial poderia incluir uma regra para emergências relativas à inundação

Usando Múltiplas Regras• (defrule fire-emergency

(emergency (type fire))=>

(printout t “Activate the sprinkler system” crlf))

• (defrule flood-emergency (emergency (type flood))=>

(printout t “Shutdown electrical equipment”crlf))

Usando Múltiplas Regras• Introduzindo do fato (emergency (type fire))

e depois dando o comando “run”, o sistema especialista irá produzir a saída:

– “Activate the sprinkler system”

Regras com Múltiplos Padrões(deftemplate extinguisher-system (slot type) (slot status))

(defrule class-A-fire-emergency (emergency (type class-A-fire)) (extinguisher-system (type water-sprinkler) (status off))=>(printout t “Activate water sprinkler” crlf)

Regras com Múltiplos Padrões(defrule class-B-fire-emergency (emergency (type class-B-fire)) (extinguisher-system (type carbon-dioxide) (status off))=>(printout t “use carbon dioxide extinguisher”

crlf))

Gravando e Lendo de Arquivos• Carregando construtores a partir de arquivos:

(load <file-name>)CLIPS> (load “file.clp”)

• Salvando construtores em arquivos:(save <file-name>)CLIPS> (save “file.clp”)

Casamento de Padrões• No que segue vamos estudar

– Variáveis para casamento de padrões– Restrições– Uso de funções– Operações de entrada e saída

Variáveis• Como em outras linguagens de programação,

variáveis em CLIPS armazenam valores• Variáveis são sempre precedidas pela marca

de interrogação (?)

CLIPS> (clear)CLIPS> (deftemplate person (slot name) (slot eyes) (slot hair))CLIPS> (defrule find-blue-eyes

(person (name ?name) (eye blue))=>

(printout t ?name “ has blue eyes.” crlf))

VariáveisCLIPS> (deffacts people (person (name Jane) (eye blue) (hair red)) (person (name Joe) (eyes brown) (hair white)) (person (name Jack) (eye black) (hair blond)) (person (name Jeff) (eyes blue) (hair brown)))

CLIPS> (reset)

CLIPS> (run)Jane has blue eyes.Jeff has blue eyes.

Múltiplos Usos de VariáveisCLIPS> (deftemplate find (slot eyes))

CLIPS> (defrule find-eyes (find (eyes ?eyes)) (person (name ?name) (eyes ?eyes)) => (printout t ?name “ has “ ?eyes “ eyes.” crlf))

Múltiplos Usos de VariáveisCLIPS> (reset)CLIPS> (assert (find (eyes blue)))CLIPS> (run) Jane has blue eyes Jeff has blue eyes

CLIPS> (assert (find (eyes brown)))CLIPS> (reset)CLIPS> (run) Joe has brown eyes

Atualizando Fatos a Partir de RHS

• Antes que um fato possa ser manipulado a partir do RHS de uma regra, deve existir uma maneira de se especificar o fato que casou com o padrão no LHS da regra, utilizando-se o operador ‘<-’

CLIPS> (clear)

CLIPS> (deftemplate person (slot name) (slot address))

CLIPS> (deftemplate moved (slot name) (slot address))


CLIPS> (defrule process-moved-information ?f1 <- (moved (name ?name) (address ?address)) ?f2 <- (person (name ?name)) => (retract ?f1) (modify ?f2 (address ?address)))

CLIPS> (deffacts example (person (name "John Hill") (address "25 Mulberry Lane")) (moved (name "John Hill") (address "37 Cherry Lane")))


• CLIPS> (reset)• CLIPS> (watch rules)• CLIPS> (watch facts)• CLIPS> (run)• /* Ver c5.clp */

Curingas• Algumas vezes é útil testar a existência de um

campo dentro de um slot sem ter que designar valor para alguma variável

• Suponha que desejamos imprimir o número de identidade de todas as pessoas com um certo sobre-nome

CLIPS> (deftemplate person (multislot name) (slot social-security-number))

Curingas(deffacts some-people (person (name John Q. Public) (social-security-number 483-98-9083)) (person (name Jack R. Public) (social-security-number 483-98-9084)) (person (name John S. Smith) (social-security-number 378-91-2037)))

(defrule print-social-security-numbers (print-ss-numbers-for ?last-name) (person (name ? ? ?last-name) (social-security-number ?ss-number)) => (printout t ?ss-number crlf))

Mundo de Blocos• Mundo de blocos

– Um bloco pode ser empilhado sobre outro bloco

– Blocos podem ser colocados no chão

– O objetivo é rearranjar as pilhas de blocos em uma configuração desejada executando o menor número possível de movimentos

Mundo de Blocos

FE

D

CB

A

Simplificações• Apenas um estado inicial é permitido

• Se o objetivo é mover o bloco x para o topo do bloco y, então– mova todos os blocos que estão no topo de

x para o chão,– mova todos os blocos que estão no topo de

y para o chão, e– mova x para o topo de y

Mundo de Blocos• Precisamos saber se um bloco está sobre outro

CLIPS> (deftemplate on-top-of (slot upper) (slot lower))

• Os fatos destas relações podem ser descritos como:CLIPS> (on-top-of (upper A) (lower B))

(on-top-of (upper B) (lower C)) (on-top-of (upper D) (lower E)) (on-top-of (upper E) (lower F))

Definindo Estado InicialCLIPS> (deftemplate on-top-of (slot upper) (slot lower))

CLIPS> (deftemplate goal (slot move) (slot on-top-of))

CLIPS> (deffacts initial-state (block A) (block B) (block C) (block D) (block E) (block F) (on-top-of (upper A) (lower B)) (on-top-of (upper B) (lower C)) (on-top-of (upper D) (lower E)) (on-top-of (upper E) (lower F)) (on-top-of (upper nothing) (lower A)) (on-top-of (upper nothing) (lower D)) (on-top-of (upper C) (lower floor)) (on-top-of (upper F) (lower floor)) (goal (move C) (on-top-of E)) )

Mover Diretamente

FE

DCA

B

• Objetivo: Mover C no topo de E

Mover Diretamente• CLIPS> (defrule move-directly ?goal <- (goal (move ?block1) (on-top-of ?block2))

(block ?block1) (block ?block2)

(on-top-of (upper nothing) (lower ?block1))?stack-1 <- (on-top-of (upper ?block1)

(lower ?block3))?stack-2 <- (on-top-of (upper nothing)

(lower ?block2))=> (retract ?goal ?stack-1 ?stack-2) (assert (on-top-of (upper ?block1)

(lower ?block2))) (printout t ?block1 " moved on top of " ?block2 "." crlf))

Movendo para o Chão

FE

D

CB

A

Movendo para o ChãoCLIPS> (defrule move-to-floor

?goal <- (goal (move ?block1) (on-top-of floor)) (block ?block1) (on-top-of (upper nothing) (lower ?block1)) ?stack <- (on-top-of (upper ?block1) (lower ?block2))

=> (retract ?goal ?stack) (assert (on-top-of (upper ?block1)

(lower floor)) (on-top-of (upper nothing)

(lower ?block2))) (printout t ?block1 " moved on top of floor." crlf))

Limpando Bloco SuperiorCLIPS> (defrule clear-upper-block

(goal (move ?block1)) (block ?block1) (on-top-of (upper ?block2) (lower ?block1)) (block ?block2) => (assert (goal (move ?block2) (on-top-of floor))))

Limpando Bloco Inferior

CLIPS> (defrule clear-lower-block (goal (on-top-of ?block1))

(block ?block1) (on-top-of (upper ?block2) (lower ?

block1)) (block ?block2)

=> (assert (goal (move ?block2) (on-top-of floor))))

ExecuçãoCLIPS> (reset)

CLIPS> (unwatch all)

CLIPS> (run)A moved on top of floor.B moved on top of floor.D moved on top of floor.C moved on top of E

(ver arquivo “c7.clp”)

Variáveis com Múltiplos Campos• No que segue exemplificamos o uso de variáveis com

múltiplos campos• Uma variável com múltiplos campos é precedida de ‘$?’

CLIPS> (deftemplate person (multislot name) (multislot children))

CLIPS> (deffacts some-people (person (name John Q. Public) (children Jane Paul Mary)) (person (name Jack R. Public) (children Rick)))

Variáveis com Múltiplos CamposCLIPS> (defrule print-children (print-children $?name) (person (name $?name) (children $?children)) =>

(printout t ?name " has children " ?children crlf))

CLIPS> (reset)CLIPS> (assert (print-children John Q. Public))

(ver “c8.clp”)

Variáveis com Múltiplos CamposCLIPS> (unwatch all)

CLIPS> (run)(John Q. Public) has children (Jane Paul Mary)

Variáveis com Múltiplos CamposCLIPS> (defrule find-child (find-child ?child) (person (name $?name) (children $?before ?child $?after))

=> (printout t ?name " has child " ?child crlf) (printout t "Other children are " $?before " " $?after crlf))

CLIPS> (reset)CLIPS> (assert (find-child Paul))(John Q. Public) has child PaulOther children are (Jane) (Mary)

(Ver “c8.clp”)

Múltiplo CasamentoCLIPS> (deftemplate person (multislot name) (multislot children))

CLIPS> (deffacts some-people (person (name John Q. Public) (children Jane Paul Mary)) (person (name Jack R. Public) (children Rick)) (person (name Joe Fiveman) (children Joe Joe Joe)))

Múltiplo CasamentoCLIPS> (defrule find-child

(find-child ?child) (person (name $?name)

(children $?before ?child $?after))=> (printout t ?name " has child " ?child crlf) (printout t "Other children are "

$?before " " $?after crlf))

CLIPS> (reset)CLIPS> (assert (find-child Joe))CLIPS> (run)

(Ver “c9.clp”)

Múltiplo CasamentoCLIPS> (run)(Joe Fiveman) has child JoeOther children are () (Joe Joe)(Joe Fiveman) has child JoeOther children are (Joe) () (Joe)(Joe Fiveman) has child JoeOther children are (Joe Joe) ()

Funções e ExpressõesCLIPS trabalha com a representação em prefixoCLIPS> (+ 2 3)5

CLIPS> (* 2 3)6

CLIPS> (/ 2 3)0.6666667

Funções e Expressões• 2 + 3 * 4

CLIPS> (+ 2 (* 3 4))14

• (2 + 3) * 4CLIPS> (* (+ 2 3) 4)20

Funções e ExpressõesCLIPS> (clear)CLIPS> (assert (answer (+ 2 2)))<Fact-0>CLIPS> (facts)F-0 (answer 4)For a total of 1 fact.

Somando Valores com RegrasCLIPS> (deftemplate rectangle (slot height) (slot

width))

CLIPS> (deffacts initial-information (rectangle (height 10) (width 6)) (rectangle (height 7) (width 5)) (rectangle (height 6) (width 8)) (rectangle (height 2) (width 5)) (sum 0))

• (Ver c10.clp)

Somando Valores com RegrasCLIPS> (defrule sum-rectangles (rectangle (height ?height) (width ?width))

=> (assert (add-to-sum (* ?height ?width))))

CLIPS> (defrule sum-areas ?sum <- (sum ?total)

?new-area <- (add-to-sum ?area)=>

(retract ?sum ?new-area) (assert (sum (+ ?total ?area))))

Somando Valores com Regras• CLIPS> (unwatch all)• CLIPS> (run)• CLIPS> (facts)• F-13 (sum 153)

Referências• Guilherme Bittencourt, Inteligência Artificial:

Ferramentas e Teorias, Editora da UFSC, 1998

• Joseph Giarratano and Gary Riley, Expert Systems: Principles and Programming, 2nd Edition, PWS Publishing Company, Boston, USA, 1993

Fim• Obrigado pela presença!

Page1 DAS-5341: Sistema CLIPS Prof. Eduardo Camponogara.

Documents

Transcript of Page1 DAS-5341: Sistema CLIPS Prof. Eduardo Camponogara.