Representation de Structures de Connaissance

Systèmes Intelligents : Raisonnement et Reconnaissance
James L. Crowley
Deuxième Année ENSIMAG
Séance 7
Deuxième Sémestre 2004/2005
23 mars 2005
Représentation Structurée de la Connaissance
Techniques Avancés de Programmation en CLIPS ....... 3
Evaluation de fonctions par "eval".......................................... 3
Definitions dynamique avec a fonction "build"......................... 3
Protocole de Communication avec "eval" et "build".................. 5
exemple d'execution d'interpret...........................................7
Regle de communication par message....................................8
Inclusion des fonctions extern dans CLIPS............................... 9
Applications de la Connaissance Structurée...............13
Frames ................................................................................ 13
Scripts :............................................................................... 16
Exemples des scripts : ........................................................... 17
Réseau Sémantique :.............................................................. 20
Conceptuel Dépendance......................................................... 20
Techniques Avancés de Programmation en CLIPS
Evaluation de fonctions par "eval"
(eval <string>)
ou
(eval <symbol_expression>)
La fonction "eval" permet d'interprèter une expression comme si il a été
tapé par l'utilisateur.
L'expression peut être une chaine de caractères ou des symboles.
exemple :
CLIPS> (eval "(+ 3 4)")
7
CLIPS> (eval "(create$ a b c)")
(a b c)
CLIPS>
;;
;; exemple de eval avec un fonction.
;;
CLIPS> (deffunction f (?a)
(printout t "f(" ?a ") = " (random) crlf))
CLIPS> (f 1)
f(1) = 16838
CLIPS> (eval "(f 2)")
f(2) = 5758
CLIPS>
Eval n'execute pas un fonction de definitions (ex.: defrule, deftemplate, declasse...)
Pour les definitions, il faut utiliser "build".
Definitions dynamique avec a fonction "build"
(build <string>)
ou
(build <symbol_expression>)
La fonction build permet l'interpretation d'une chaine de caractere
contenant une definition CLIPS , (ex.: defrule, deftemplate, declasse...).
build retourne TRUE si la definition a marché et FALSE s'il y a eu une erreur.
;;
;;
;;
exemple de build
CLIPS> (build "(deffunction g (?a) (return ?a)")
TRUE
CLIPS> (g whiz)
whiz
;; qu'est ce passe si on fait ceci?
CLIPS> g(whiz)
g
Une Probleme : les guillements dans une chaine de caractères
Il faut les preceder les guillement par \
CLIPS> (build "(deffunction f (?a)
(printout t \"f(\" ?a \") = \" (random) crlf )"
)
TRUE
CLIPS>(f 1)
f(1) = 31051
CLIPS>(eval "(f 1)")
Build permet des règles en CLIPS de construire d'autre règles.
exemple :
;;
;; build d'un regle
;;
(defrule regle-construit
(a b c)
=>
(printout " (a b c) existe " crlf)
)
peut etre construit par :
(build "(defrule regle-construit (a b c)
=> (printout t \" (a b c) existe \" crlf) )"
)
Le chaine de caractère peut être composer par un ensemble de règles.
Protocole de Communication avec "eval" et "build"
Avec "build" et "eval", Deux processus CLIPS communicant par Socket peut se
definir leur protocole de communication dynamiquement.
C.-a-d. Un processus CLIPS peut programmer un autre.
Processus A programme processus B par message
(deffunction foo ...)
Module A
Module B
Processus B reception le nouvelle fonction "foo".
Module A
Module B
(build (deffunction foo ...))
Processus A peut ensuite executer fonction foo par message a Procesus B
(foo args)
Module A
Module B
Processus B interpret the message ...
Module A
Module B
( eval (foo args))
.... et retourne un resultat.
( eval (foo args))
Module A
Module B
Si un message commence par ""(def..." on appel "build" sinon "eval".
Soit les fonction d'envoie et reception "send-mess" et "get-mess".
(deffunction interpret ()
(bind ?mess (get-mess))
(bind ?sub (sub-string 2 4 ?mess))
(if (eq ?sub "def")
then (build ?mess)
else (eval ?mess))
)
On peut verifier que la message est a "interpreter" en testant
si le premiere caractere est un "(".
(deffunction interpret ()
(bind ?mess (get-mess))
(if (neq (sub-string 1 1 ?mess) "(")
then (printout t "message : " ?mess crlf)
(return TRUE)
else
(bind ?sub (sub-string 2 4 ?mess))
(if (eq ?sub "def")
then (build ?mess)
else (eval ?mess))
)
)
On peut simuler send-mess et get-mess avec printout et readline.
;;
;;
send-mess permet l'envoie d'une message par "socket"
on simule send-mess ici avec printout
(deffunction send_mess (?message) (printout ?message))
;; get-mess recoit une message par socket.
;; On simule get-mess avec readline
(deffunction get-mess ()
(printout t "Message? ")
(return (readline)))
exemple :
CLIPS> (send-mess "This is a test")
This is a test
CLIPS> (get-mess)
Message? this is a test
"this is a test"
CLIPS>
;; interrogation
;; reponse
On peut interpreter les message par la fonction "interpret".
(deffunction interpret ()
(eval (get-mess))
)
Exemple :
CLIPS> (deffunction send-mess (?message) (printout t ?message
crlf))
CLIPS> (deffunction get-mess () (printout t "Message? ") (return
(readline)))
)
CLIPS> (deffunction interpret () (eval (get-mess)))
CLIPS> (interpret)
Message? (assert (a b c))
<Fact-0>
CLIPS> (facts)
f-0
(a b c)
For a total of 1 fact.
CLIPS>
exemple d'execution d'interpret
CLIPS> (interpret)
Message? this is a test
message : this is a test
CLIPS> (interpret)
Message? (assert (this is a test))
<Fact-0>
CLIPS> (facts)
f-0
(this is a test)
For a total of 1 fact.
CLIPS> (interpret)
Message? (deftemplate A (slot b) (slot c))
TRUE
CLIPS> (interpret)
Message? (assert (A (b "test")))
<Fact-1>
CLIPS> (facts)
f-0
(this is a test)
f-1
(A (b "test") (c nil))
For a total of 2 facts.
CLIPS>
Regle de communication par message
On peut avoir une regle qui recoit et interpret les messages :
(defrule get-message
?go <- (go)
(not (stop))
=>
(retract ?go) (assert (go))
(send-mess (interpret))
)
CLIPS> (run)
Message? this is a test
message : this is a test
TRUE
Message? (assert (this is a test))
<Fact-19>
Message? (deffunction stop () (assert (stop)))
TRUE
Message? (deffunction f1 (?x ?y) (+ ?x ?y))
TRUE
Message? (f1 1 2)
3
Message? (deffunction f2 (?x ?y) (* ?x ?y))
TRUE
Message? (f2 2 3)
6
Message? (stop)
<Fact-10>
CLIPS>
Inclusion des fonctions extern dans CLIPS
CLIPS est un système ouvert ("Open System" en anglais)
Il est écrit en C et distribué avec sa code source.
Ceci rend facil l'inclusion de fonctions extern, écrit par l'utilisateur,
dans l'environnement de l'interpret.
L'extension de CLIPS est decrit dans le manual :
Vol 2 : Advanced Programming Guide
Pour ajouter une fonction extern il faut
1) compiler le fonction.
2) Ajouter une declaration de la fonction et ses parametres dans main.c
3) Inclure son code objet (fonction.o) dans le "make-file"
et refaire le "make".
Les fonctions sont declarés avec DefineFunction ou DefineFunction2
int
DefineFunction(functionName,functionType,
functionPointer,actualFunctionName);
int
DefineFunction2(functionName,functionType,
functionPointer,actualFunctionName,
functionRestrictions);
char *functionName, functionType, *actualFunctionName;
int
(*functionPointer)();
char
*functionRestrictions
Exemple des declarations :
UserFunctions()
{
/* Declare your C functions if necessary. */
extern double ma_fonc();
extern VOID *dummy();
/* Call DefineFunction to register user-defined functions. */
DefineFunction("fonc",'d',ma_fonc,"ma_fonc");
}
1
Les paramètres de DefineFonction sont
1) La nom à utiliser dans l'interpreter CLIPS.
Pas forcement le meme que le nom du fonction ecrite en "c".
2) Le type de resultat rendu par le fonction. (ici un double).
3) L'adresse de la fonction.
4) Une representation en chaine de caractere (STRING) de l'adresse de la fonction.
Il est possible de declarer la fonction avec ses arguments en utilisant
"DefineFunction2".
int
char
int
char
DefineFunction2(functionName,functionType,
functionPointer,actualFunctionName,
functionRestrictions);
*functionName, functionType, *actualFunctionName;
(*functionPointer)();
*functionRestrictions
Les premieres 4 arguments sont les memes que DefineFonction.
Le cinquième est une chaine de caracteres decrivant les arguments.
Cette chaine a le format :
<min-args> <max-args> [<default-type> <types>*]
Explications : <min-args> <max-args> : des entiers ou "*"
Exemples :
La communication entre deux processus CLIPS sur deux machines
differents peut etre assurer par les procedures en C : transmet() et recoit().
La procedure "transmet()" permet de transmetre une chaine "message".
On veut que sa nom en CLIPS soit "send_mess".
Il return un code d'erreur ou NULL si le message est transmit.
La procedure "recoit()" permet de recoit une chaine "message".
On veut que sa nom en CLIPS soit "get_mess".
Il return une chaine ou une code d'erreur.
int transmet(char * message; )
{...
}
char *
{...
}
recoit()
Dans main.c :
DefineFunction2(send-mess, 'i', transmet, "transmet", "11s");
DefineFunction(get-mess, 's', recoit, "recoit");
Les codes des types de retour sont :
Return Code Return Type Expected
a
b
c
d
f
i
j
k
l
m
n
o
s
u
v
w
x
External Address
Boolean
Character
Double Precision Float
Single Precision Float
Integer
Unknown Data Type (Symbol, String, or Instance Name Expected)
Unknown Data Type (Symbol or String Expected)
Long Integer
Multifield
Unknown Data Type (Integer or Float Expected)
Instance Name
String
Unknown Data Type (Any Type Expected)
Void—No Return Value
Symbol
Instance Address
Des codes de types pour les paramètres sont.
Type Code
Allowed Types
a
d
e
f
g
h
i
j
k
l
m
External Address
Float
Instance Address, Instance Name, or Symbol
Float
Integer, Float, or Symbol
Instance Address, Instance Name, Fact Address, Integer, or Symbol
Integer
Symbol, String, or Instance Name
Symbol or String
Integer
Multifield
n
o
p
q
s
u
w
x
y
z
Integer or Float
Instance Name
Instance Name or Symbol
Symbol, String, or Multifield
String
Any Data Type
Symbol
Instance Address
Fact Address
Fact address, Integer, or Symbol
Applications de la Connaissance Structurée
L'expression de la connaissance déclarative par structure de schéma a plusieurs
applications. Trois applications classique sont les Frames, les Scripts et les Réseaux
Sémantiques.
Frames :
Un assemblage des objets pour décrire une scène.
Script :
Un assemblage des objets pour décrire une séquence des événements
Réseau Sémantique : Un assemblage des objets pour décrire le sens sémantique d'un
texte.
Frames
(Table-Scene (is-a scene)
(Surface [Table])
(Objets [Cube])
)
(Cube (is-a entity)
(front [P1])
(side [P2])
(top [p3])
)
(rect (is-a polygon)
(name [p1]
(edges l1, l2, l3 l4)
)
Les "Frames" était proposée par Minsky pour représenter les scènes. Depuis les
concepts à été généralisé, et maintenant on trouve le terme frame utilisé en
synonyme avec "schéma".
Un frame est une description d'un contexte composé d'une collection de rôles et
relations. Ceci donne une description “explicite” du contexte qui peut servir de
guider l’interprétation s'une scène, d’une situation ou d'une histoire.
La structure d’une frame permet de faire les inférences par raisonnement par
défaut.
Exemple d'une Frame pour un Vol Air France :
LHR
from
AF357
to
LYS
Ceci correspond à des objets CLIPS :
(defclass AIRPORT (is-a USER)
(role concrete)
(slot code (create-accessor read-write))
(slot AD-name (create-accessor read-write))
(slot city (create-accessor read-write))
(slot country (create-accessor read-write))
)
(make-instance [LYS] of AIRPORT (code LYS)
(AD-name Satolas) (city Lyon) (country France))
(make-instance [LHR] of AIRPORT (code LHR)
(AD-name Heathrow) (city London) (country Britain))
(defclass FLIGHT (is-a USER)
(role concrete)
(slot code (type SYMBOL)(create-accessor read-write))
(slot from (type INSTANCE)(create-accessor read-write))
(slot to (type INSTANCE)(create-accessor read-write))
(message-handler from-city)
(message-handler to-city)
)
(defmessage-handler FLIGHT from-city()
(send ?self:from get-city))
(defmessage-handler FLIGHT to-city()
(send ?self:to get-city))
(make-instance [AF357] of FLIGHT
(from [LHR]) (to [LYS])(code AF357)
)
On peut ensuite poser des questions telles que “d'où vient le vol AF 357”
CLIPS> (send [AF357] from-city)
London
CLIPS> (send [AF357] to-city)
Lyon
Exemple : Frame pour un person
Pour l'exemple qui suit, on aura besoins d'un Frame pour person.
(defclass PERSON (is-a USER)
(role concrete) (pattern-match reactive)
(slot last-name (create-accessor read-write))
(slot first-name (create-accessor read-write))
(slot location (create-accessor read-write))
(message-handler who-is)
(message-handler where-is)
)
(defmessage-handler PERSON who-is ()
(str-cat ?self:first-name " " ?self:last-name)
)
(defmessage-handler PERSON where-is ()
(if (neq ?self:location nil)
then (send ?self:location where-is)
else (printout t "I dont know where ?self:first-name is"
crlf))
)
(defmessage-handler PERSON what-city-is ()
(if (neq ?self:location nil)
then (send ?self:location get-city)
else (printout t "I dont know where ?self:first-name is"
CRLF))
)
(make-instance [Jim] of PERSON
(last-name Crowley) (first-name James)
)
(defclass PLACE (is-a USER)
(role concrete) (pattern-match reactive)
(slot place-name (create-accessor read-write))
(slot city (create-accessor read-write))
(slot country (create-accessor read-write))
(message-handler where-is)
)
(defmessage-handler PLACE where-is ()
(return ?self:place-name)
)
(make-instance [Home] of PLACE
(place-name chez-moi)
(city Meylan)
(country France)
)
(send [Jim] where-is)
(send [Jim] put-location [Home])
(send [Jim] where-is)
Scripts :
Un Script est une structure de schémas utilisés pour décrire une séquence
d’événements. Un script est une forme de connaissance déclarative qui peut servir
1) communiquer, comprendre et raisonner sur une histoire
2) comprendre ou raisonner sur une situation ou une séquence d'événements
3) raisonner sur les actions
4) planifier les actions
Un script est composé de :
1) Une scène (en lieu et ses composants).
2) Des "props" (Les objets manipulés dans le script).
3) Les acteurs
4) Des actions
6) Les événements : Un changement de situation ou Contexte
7) Les contextes. Une association de rôles et relations.
Le script est une structure de contextes. Dans chaque contexte, un ou plusieurs
acteurs font les actions. Les acteurs agissent dans les lieus de la scène avec les props.
Les contextes peuvent être organisé en séquence, arbre ou réseau.
Le script aide à l’interprétation et à la communication par fournissant les éléments
primitifs est les méthodes de leur reconnaissance.
En outre, une scripte permet de prédire les actions et événements possibles et les
nouveaux contextes qu’on découle.
Exemples des scripts :
1) Manger dans une bonne restaurant française
Scène :
Acteurs :
Props :
La (les) salle(s), l'entrée, les tables (comme lieu), la cuisine
Le maître d’Hôtel, Le serveur, la "bus-boy", les clients
le menu la table (comme objet), les chaises, les couteaux, fourchettes et
cuillers, la (les) verre(s)
Actions:
Entrer, S'asseoir, lire le menu, commander, manger, boire, demander
l'addition, payer, partir.
Contextes:
Les phases du repas (arriver, s'installer, commander, manger, payer)
La scène, les acteurs, le props, les actions, les contextes sont tous représenté par les
schéma.
2) Achat d’une boisson au distributeur automatique
Scène :
Props:
Acteur :
actions :
devant la machine
La machine, les pieces de monnaie, la boisson, le gobelet,
acheteur
1) Sortir tes pieces de monnaie
2) Payer
3) Sélectionner la boisson et les options (sucre, crème, etc.)
4) Recouper la boisson et le monnaie
Exemple d’un script hiérarchique
Une scripte est typiquement une "hiérarchie" des contextes.
Les contextes sont composés d'actions. Chaque action est aussi une scripte.
Le résultat est un arbre "Et-ou".
Pour chaque action il y a une séquence (ou réseau) de contextes
Pour chaque contexte il y a une liste d'actions possible
Exemple : Aller à Paris
Niveau 1 : action : Aller à Paris
Contextes : Aller en train, aller en avion, aller en voiture, aller en auto-stop
Niveau 1 : Contexte : Aller en train:
Actions : aller a la gare, acheter un billet, voyager, arriver
Niveau 2 : Action: aller au gare
Contextes : aller en bus, aller en taxi, aller en automobile
Niveau 2 : Context: aller en bus,
actions : Aller à l’arrêt bus, attendre, monter sur le bus, aller, sortir à la gare
Travel to Paris
Travel-by-Train
Go to Gare
Bus
Go to Bus
Taxi
Wait
Buy Ticket
Automobile
Ride Bus
Travel-by-Plane
Travel
Arrive
Travel by Automobile
(defclass SCRIPT (is-a USER)
(role concrete) (pattern-match reactive)
(part-of (create-accessor read-write))
(slot scene (create-accessor read-write))
(slot actor (create-accessor read-write))
(multislot props (create-accessor read-write))
(multislot actions (create-accessor read-write))
)
(defclass TRAVEL-SCRIPT (is-a SCRIPT)
(role concrete) (pattern-match reactive)
(slot mode (create-accessor read-write))
(slot provenance (create-accessor read-write))
(slot destination (create-accessor read-write))
(multislot possible-travel-modes (create-accessor readwrite))
)
(make-instance [Travel-to-Paris] of TRAVEL-SCRIPT
(actor [Jim])
(destination [Paris])
(possible-travel-modes [Travel-by-Train] [Travel-byplane] [Travel-by-auto])
)
(defrule find-actor
?action <- (object (is-a TRAVEL-SCRIPT )
(actor ?a)
(provenance nil))
=>
(send ?action put-provenance (send ?a what-city-is))
)
(make-instance Travel-by-Train of TRAVEL-SCRIPT
(part-of [Travel-to-Paris]
(props [Ticket] [Train])
(actions
[Go-to-Station] [Buy-Ticket] [Find-Train]
[Find-seat] [Travel])
)
(make-instance Go-to-Station of TRAVEL-SCRIPT )
(part-of [Travel-by-Train]
(provenance [Home])
(destination [Station])
(possible-travel-modes [Taxi] [Auto] [Bus] [Walk])
)
(make-instance [Paris] of PLACE
(place-name Paris)
(city Paris)
(country France)
)
Réseau Sémantique :
Comment représenter la “sémantique” d’une phrase ou d'une scène?
Les réseaux sémantiques utilisent les schémas pour fournir une expression
symbolique de la "sens" des mots. Ils sont utilisés pour les systèmes de traduction
automatique.
La sémantique des mots est exprimée par référence à une hiérarchie de concepts
abstrait. L'approche des "Réseaux Sémantiques" est de définir un ensemble de
prédicats “primitifs”. Les mots sont définis comme une conjonction de ses
primitifs.
Exemple :
∀ x (Father(x) →
parent(x) ∧ mâle(x) )
Dans une base de connaissance, on remplace chaque mot par sa définition.
Cette idée a inspiré plusieurs efforts de définir un vocabulaire de concepts
“de base” pour la langue naturelle.
Conceptuel Dépendance
Dans les années 70, Shanks a proposé une théorie qui s’appelle :
“Conceptual Dependance” Le CD est un ensemble de “primitives” réduit. Par
exemple, il y a trois primitifs basés sur le concept de transfert.
ATRANS : Transfère Abstrait. (Tel que transfère de la possession d’une chose)
PTRANS : Transfert Physique
MTRANS : Transfert Mental.
Il y aussi d’autres primitifs tels que :
CONC : Conceptualise - construire une description abstrait
MBUILD : Build Mental - Inférence
MOVE : Mouvement d’une partie du corps
GRASP : Saisir
INGEST : Ingérer
EXPEL : Inverse d’ingérer
Les plus part des verbes peut être exprimé en termes de ces primitifs.
Il s’agit d’une branche d'ontologie : l'Étude de concept et catégories.
Exerci