LucidiLez.SistemiRegole-parte1

Sistemi a Regole
Fabio Sartori
26 Novembre 2008
Sommario
•  Introduzione ai sistemi a regole
  Un esempio dall’enigmistica
  Architettura
  Fatti
  Regole
•  Introduzione a JESS
  Ambiente per lo sviluppo di sistemi a regole
  Sintassi ed esempi
1
Sistemi a Regole: cosa sono?
Problema
Output Parziali
Input
Output
+
2006
Output
Conoscenza
Dal primo input si deduce che:
•  L’ultimo anno è il 2006
•  La vincitrice del 2006 è Zuleyka Rivera Mendoza
•  Zuleyka Rivera Mendoza non è australiana
Fatti
Ragionamento
Output parziale
  L’ultima vincitrice è stata Zuleyka Rivera Mendoza
  L’ultimo anno è il 2006
allora
  La vincitrice del 2006 è Zuleyka Rivera Mendoza
Regole
In base alla deduzione
se
2
KBS e Sistemi a Regole
Knowledge-based System (KBS):
  Sistemi Rule-based (a regole)
 Sistemi Model-based
  Sistemi CBR-based
 Sistemi ibridi
Sistemi a Regole: applicazione ciclica di regole che operano su una memoria di lavoro
contenente i fatti al fine di derivare fatti nuovi da fatti noti
Un sistema a regole contiene un insieme di regole che specificano delle condizioni di
attivazione e degli effetti
In particolare, ciascuna regola ha la forma <condizioni> => <azioni>
talvolta anche descritte come <LHS - Left Hand Side> => <RHS - Right Hand Side>
Esempi di regole:
madre(x) = madre(y)
padre(x) = padre(y)
Maschio(x)
=>
Fratello(x, y)
madre(x) = madre(y)
padre(x) = padre(y)
Femmina(x)
=>
Sorella(x, y)
Architettura generale
Knowledge Base
[rules and initial facts]
Inference Engine
Agenda
Working Memory
[facts]
User Interface
3
Architettura generale
Knowledge Base
[rules and initial facts]
Inference Engine
Agenda
Working Memory
[facts]
User Interface
I Fatti sono asserzioni su proprietà, relazioni, proposizioni etc. nella forma di stringhe
Servono a descrivere gli stati della computazione, compreso lo stato iniziale
Sono statici e inattivi rispetto al valore pragmatico e all’utilizzazione dinamica della
conoscenza che contengono
Memoria di lavoro
La Working Memory (Memoria di Lavoro) è un dispositivo
utilizzato per trattenere asserzioni temporanee (informazioni
sullo stato del problema da risolvere)
Femmina(Amelia)
Femmina(Alba)
(madre(Amelia) = Paola)
(madre(Alba) = Paola)
(padre(Amelia) = Mario)
(padre(Alba) = Mario)
Architettura generale
Knowledge Base
[rules and initial facts]
Inference Engine
Agenda
Working Memory
[facts]
User Interface
Le Regole corrispondono a dati strutturati in forma IF-THEN impiegati dal motore inferenziale
per inferire una soluzione al problema proposto.
Si possono vedere come le unità base dell’inferenza che porta dalla descrizione dello stato
iniziale alla soluzione del problema.
Regola
Sono costrutti condizionali composti da due parti: LHS e RHS
madre(x) = madre(y)
padre(x) = padre(y)
Femmina(x)
=>
Sorella(x, y)
4
Architettura generale
Knowledge Base
[rules and initial facts]
Inference Engine
Agenda
Working Memory
[facts]
User Interface
L’ Agenda è un dispositivo utilizzato per
trattenere l’elenco delle regole attivate dai fatti
presenti attualmente nella memoria di lavoro. Il
suo contenuto varia dinamicamente durante
l’esecuzione (Firing) delle regole stesse.
Una regole si dice Attivata se la condizione da
essa espressa è verificata.
Memoria di lavoro
Femmina(Amelia)
Femmina(Alba)
(madre(Amelia) = Paola)
(madre(Alba) = Paola)
(padre(Amelia) = Mario)
(padre(Alba) = Mario)
Una regola si dire Fired se le operazioni in
essa indicate sono state eseguite
Regola
madre(x) = madre(y)
padre(x) = padre(y)
Femmina(x)
=>
Sorella(x, y)
Un sistema termina la computazione quando
non si hanno più regole attive in agenda
Interprete delle regole
Pattern Matching [costruzione dell’Agenda]: 1) l’interprete considera ciascuna regola rispetto alla
situazione corrente 2) compara i valori che compaiono nella LHS con gli elementi di memoria corrispondenti
per identificare quelle per le quali sono soddisfatte le LHS
Algoritmo RETE: complessità nella costruzione del conflict set da esponenziale a polinomiale "Rete: A Fast Algorithm for the Many Pattern/ Many Object
Pattern Match Problem", Charles L. Forgy, Artificial Intelligence 19 (1982), 17-37.”
Risoluzione dei conflitti: se vengono individuate più corrispondenze, l’interprete le immette nel
CONFLICT SET e le tiene in considerazione come possibili candidati per l’esecuzione.
Il processo di RISOLUZIONE DEI CONFLITTI seleziona l’ESEMPLARE DOMINANTE di regola basandosi su
una STRATEGIA DI RISOLUZIONE DEI CONFLITTI, ad esempio dando precedenza a:
- Regole più specifiche (con più pattern nella LHS) o più generiche (meno fatti nella LHS)
- Regole attivate da fatti asseriti più di recente
Esecuzione [Firing delle regole]: esegue le azioni descritte dal membro di destra dell’ESEMPLARE
DOMINANTE selezionato dal CONFRONTO (o eventualmente dal RISOLUTORE DEI CONFLITTI)
Pattern Matching
Risoluzione dei conflitti
Esecuzione
Stop
5
Esecuzione delle regole
Memoria di lavoro
Regola
Memoria di lavoro
Femmina(Amelia)
Femmina(Alba)
(madre(Amelia) = Paola)
(madre(Alba) = Paola)
(padre(Amelia) = Mario)
(padre(Alba) = Mario)
madre(x) = madre(y)
padre(x) = padre(y)
Femmina(x)
=>
Sorella(x, y)
Femmina(Amelia)
Femmina(Alba)
(madre(Amelia) = Paola)
(madre(Alba) = Paola)
(padre(Amelia) = Mario)
(padre(Alba) = Mario)
Sorella(Alba, Amelia)
Regole IF-THEN: alcuni esempi
LHS
RHS
Situazione
Azione
Premessa
Conclusione
if acqua scarseggia then papera non galleggia
Antecedente
Conseguente
if x is a dog then x is an animal
if temp > 300° then stop boiler
Ogni Left-Hand Side (LHS) contiene Elementi
condizione: condizioni che devono essere verificate
affinchè la regola sia appilcata
Ogni Right-Hand Side (RHS) contiene la descrizione di
Azioni: azioni che bisogna condurre a effetto quando la
regola viene eseguita
Ogni LHS è una Clausola logica e condizione
sufficiente per eseguire l’azione indicata nella RHS
Le azioni possibili includono attività come:
Queste “condizioni” vengono assegnate descrivendo
delle configurazioni (di solito di parti) della memoria
globale: vengono specificati gli identificatori degli
elementi di memoria insieme agli attributi ad essi
associati e ai valori richiesti nella condizione
- inserire nuove descrizioni di stato nella memoria
globale
- modificare descrizioni di stato già esistenti
- eseguire azioni definite dall’utente per una
produzione particolare
6
Introduzione a JESS
Introduzione
•  Shell per sistemi a regole implementato in Java
•  Realizzato da
Ernest J. Friedman-Hill
Distributed Computing Systems
Sandia National Laboratories
Livermore, CA - USA
•  Disponibile presso:
http://herzberg.ca.sandia.gov/jess
•  Licenza gratuita per usi non-commerciali
7
Elementi di un programma JESS
Definire un programma Jess comporta
  La specifica di un insieme di regole di produzione
  La definizione dei fatti iniziali che vanno a comporre la memoria di lavoro all’atto
dell’inizializzazione del motore inferenziale
  La specifica di comandi opzionali (ad es. per attivare automaticamente il motore
inferenziale al caricamento del programma)
É possibile usare JESS in due modi
•  In applicazioni JAVA
•  Stand-alone (tramite Console) java jess.Console
1.  inserire comandi dalla linea di comandi della console
2.  da linea di comando eseguire batch nome del file .clp
Comandi Gestione IN/OUT
Comandi Gestione Computazione
Comandi Gestione Fatti e Regole
Java
Expert
System
Shell
Esempio hello.clp
;(clear)
(defrule hello "prints Hello world"
(initial-fact)
=>
(printout t "Hello world!" crlf)
)
(reset)
Dalla Console:
Jess> (run)
Hello world!
1
Jess>
8
Esempio sort.clp
(deffacts initial-facts
(lista ld 6 2 3 1 5 4)
(sort ld))
(defrule sort-list
?tmp <- (sort ?lname)
?oldlist <- (lista ?lname $?A ?x ?y $?R)
(test (> ?x ?y))
=>
(assert (lista ?lname ?A ?y ?x ?R))
(printout t "Scambiato " ?x " con " ?y
crlf)
(retract ?oldlist))
(defrule stop-sorting
(declare (salience -100))
?tmp <- (sort ?lname)
=>
(retract ?tmp))
(facts)
(reset)
(facts)
(run)
(facts)
Dalla Console:
For a total of 0 facts.
f-0 (initial-fact)
f-1 (lista ld 6 2 3 1 5 4)
f-2 (sort ld)
For a total of 3 facts.
Scambiato 5 con 4
Scambiato 3 con 1
Scambiato 2 con 1
Scambiato 6 con 1
Scambiato 6 con 2
Scambiato 6 con 3
Scambiato 6 con 4
Scambiato 6 con 5
f-0 (initial-fact)
f-10 (lista ld 1 2 3 4 5 6)
For a total of 2 facts.
Variabili & Multivariabili & Variabili
Globali
Ogni nome di variabile è costituito da un atomo preceduto dal simbolo (?)
•  Assumono valori di atomi, numeri o stringhe
•  La funzione bind assegna un valore ad una variabile:
(bind ?x “The value”)  ?x ha valore “The value”
(bind ?a 124)  ?a ha valore 124
Se il nome è preceduto da $ la variabile è una multivariabile
(bind $?grocery-list (create$ eggs bread milk))
$?grocery-list ha valore (eggs bread milk)
Per definire una variabile globale si usa:
(defglobal [?<global-name> = <value>]*)
Il <global-name> deve essere racchiuso tra (*)
Esempi:
(defglobal ?*counter* = 0
?*a* = “prova” ) definisce le variabili ?*a* e ?*counter*
9
Funzioni
In Jess si usa la notazione prefissa ... come in LISP
Le condizioni e le azioni possono includere chiamate a funzioni
Esempi:
(+ 2 3)
(> (+ 2 3) 10)
Per definire una nuova funzione di JESS si usa il comando
(deffunction <nome> [<commenti>] (<parametri>*)
<espr>*
[<return>])
Esempio:
(deffunction max (?a ?b)
(if (> ?a ?b) then ?a
else ?b))
  definita la funzione “max”, possiamo scrivere l’istruzione: (bind ?max (max 5 3))
La memoria di lavoro
• 
• 
I fatti presenti nella memoria di lavoro (Working Memory) sono
ordinati in una lista: la fact list
Ad ogni fatto della memoria di lavoro è associato un identificatore: il
fact-id
All’inizio dell’esecuzione è asserito un fatto iniziale (initial-fact)
• 
Nella memoria di lavoro possono essere caricati:
• 
  Fatti ordinati
  Fatti non ordinati
  Shadow Facts
10
Fatti ordinati
Un fatto ordinato è una lista di atomi, stringhe, numeri.
Si tratta di fatti non strutturati
Il primo atomo di questa lista (head del fatto) serve ad identificare una categoria di fatti
Esempi:
(shopping-list eggs milk bread)
(person “Bob Smith” Male 35)
I fatti sono contenuti nella memoria di lavoro
• 
• 
Per aggiungere nuovi fatti alla memoria di lavoro si usa il comando
(assert <fatto>)
(assert (shopping-list eggs milk bread))
(assert (person “Bob Smith” Male 35))
Per togliere dei fatti presenti nella memoria di lavoro si usa il comando
(retract <id-fatto>)
(retract ?x)  dove ?x contiene l’id del fatto da eliminare
Fatti non ordinati
Si tratta di fatti strutturati
Per definire questi fatti è necessario dichiarare quale deve essere la struttura
(deftemplate <nome> [extends <classname>] [<commenti>]
(slot <nomeSlot> [(default | default-dynamic <value>)] [(type
<typespec>))]*)
(deftemplate auto extends mezziDiTrasporto
(slot model)
(slot anno)
(slot colore (default bianco))
(assert (auto (model Fiat-Punto) (anno 2000) (colore rosso))
(assert (auto (model Ford-Focus) (anno 2006))
NB: l’ordine degli slot non è rilevante
11
Asserire insiemi di fatti
(deffacts <nome> [<commento>]
[<fatto>]*)
(deffacts inizio
(prova 1 2)
(secondaprova))
• 
i fatti possono essere sia ordered che unordered, con uguale o diversa
struttura
• 
dopo il comando deffacts, al fine di asserire efettivamente i fatti nella
memoria di lavoro, è necessario inserire il comando (reset)
Regole
Per inserire nuove regole nella base della conoscenza si usa il comando defrule:
(defrule <nome> [<commento>]
[(declare...)]
[<condition-element>]*
=>
[<funzione>]*)
• 
• 
La parte LHS di una produzione in Jess, è un elenco di Condition Element (non
conta l’ordine)
La parte RHS di una produzione in Jess è un elenco di Azioni
  cambiando l’ordine delle azioni della RHS, lo stato in cui porta l’esecuzione delle
regole può cambiare
  Azioni più comuni:
  aggiungere un elemento alla working memory
(assert (Espressione (Nome E54) (Arg1 1)))
  modificare un attributo presente nella working memory
(modify ?x1 (Op nil) (Arg2 nil)) )
  eliminare un elemento dalla working memory
(retract ?x1)
12
Salience delle regole
Ogni regola è dotata di una proprietà detta salience, che ne
rappresenta la priorità
Fra le regole attivate e presenti nell’agenda verranno considerate
quelle con salience maggiore
(defrule prima-mangia
?eat (food ?any)
(not (full))
=>
(retract ?eat)
(assert (full)))
(defrule poi-dividi
(declare (salience -100))
?give  (food ?any)
=>
(assert (share ?any))
(retract ?give))
Condition Element
<condition-element> =
<pattern>
or
<NOT-CE> | <AND-CE> | <OR-CE> | <test-CE>
Pattern: descrizioni, anche parziali, di fatti; se esistono fatti nella WM
che corrispondano a questa descrizione, questo CE sarà verificato
Altri CE:
•  NOT: verificato se il CE associato non è verificato
•  AND/OR: verificati se rispettivamente tutti o almeno uno dei CE
associati sono verificati
•  test: permette di specificare delle condizioni (ad esempio su parti
di pattern o su variabili)
13
Definizione di una regola
(defrule moltiplicazione-x-0
(declare (salience 10))
(Goal (Tipo semplificazione) (Oggetto ?X))
?x1  (Espressione (Nome ?X) (Arg1 0) (Op *))
=>
(modify ?x1 (Op nil) (Arg2 nil)) )
Esempio di Regola (ordered facts)
( defrule fratelli_mamma
(madre ?mamma ?figlio1)
(madre ?mamma ?figlio2)
(test (neq ?figlio1 ?figlio2))
(not (fratelli ?figlio1 ?figlio2))
(not (fratelli ?figlio2 ?figlio1))
=>
(assert (fratelli ?figlio1 ?figlio2))
)
(madre Marge Lisa)
(madre Marge Bart)
(madre Marge Maggie)
(madre Marge Lisa)
(madre Marge Bart)
(madre Marge Maggie)
(fratelli Maggie Bart)
(fratelli Maggie Lisa)
(fratelli Bart Lisa)
14
Esempio di Regola
(unordered facts)
(deftemplate madre
(deftemplate fratelli
(slot genitore) (slot figlio))
(slot fratello1) (slot fratello2))
( defrule fratelli_mamma
(madre (genitore ?mamma) (figlio ?figlio1))
?x1 <- (madre (genitore ?mamma) (figlio ?figlio2~?figlio1))
=>
(assert (fratelli (fratello1 ?figlio1) (fratello2 ?figlio2)))
)
Altre funzioni importanti
• 
(facts)  visualizza la fact-list (la working memory di Jess)
• 
(agenda)  visualizza il contenuto dell’agenda
• 
(reset)  ripristina la situazione iniziale di variabili globali, deffacts,
(initial-fact)
• 
(clear)  svuota l’agenda e la working memory
• 
(run)  inizia l’esecuzione delle regole
• 
(halt)  ferma l’esecuzione delle regole
15