Page1

DAS-5341: Sistema CLIPS

Prof. Eduardo Camponogara

Page2

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

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

Page3

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

Page4

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

Page5

Entrando e Saindo do CLIPS• Exemplo:

CLIPS> (+ 3 4)7

• Saindo do CLIPS(exit)

Page6

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

Page7

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”

Page8

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

Page9

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.

Page10

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

Page11

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

Page12

Lista de Fatos• Para inspecionar a lista de fatos basta

executar o comando (facts)CLIPS> (facts)

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

Page13

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)

Page14

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

Page15

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

Page16

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

Page17

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

Page18

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?

Page19

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

Page20

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}

Page21

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

Page22

A Sintaxe de Defrule

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

=><actions>* ; lado direito da regra

Page23

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

Page24

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

Page25

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

Page26

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

– (Executar código diretamente com CLIPS)

Page27

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

Page28

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

Page29

Comandos Manipuladores• Deletando um certo construtor

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

Page30

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

Page31

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

Page32

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

Page33

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”

Page34

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)

Page35

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

Page36

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

Page37

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

Page38

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

Page39

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.

Page40

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

Page41

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

Page42

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

Page43

Atualizando Fatos a Partir de RHS

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

Page44

Atualizando Fatos a Partir de RHS

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

Page45

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

Page46

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

Page47

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

Page48

Mundo de Blocos

FE

D

CB

A

Page49

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

Page50

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

Page51

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

Page52

Mover Diretamente

FE

DCA

B

• Objetivo: Mover C no topo de E

Page53

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

Page54

Movendo para o Chão

FE

D

CB

A

Page55

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

Page56

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

Page57

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

Page58

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

Page59

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

Page60

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

Page61

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

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

Page62

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

Page63

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

Page64

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

Page65

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

Page66

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

CLIPS> (* 2 3)6

CLIPS> (/ 2 3)0.6666667

Page67

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

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

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

Page68

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.

Page69

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)

Page70

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

Page71

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

Page72

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

Page73

Fim• Obrigado pela presença!