Upload
levi-belmonte-almeida
View
224
Download
0
Embed Size (px)
Citation preview
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!