Representation Structuré de la Connaissance

Systèmes Experts
3 eme Année ENSIMAG 2000/2001
James L. Crowley
Séance 7 :
27 novembre 2000
Représentation Structurée de la Connaissance
Représentation Structurée de la Connaissance ............. 2
Techniques..............................................................................2
Terminologie :........................................................................3
Quatre Principes (+1) ..............................................................4
Définition des Classes en CLIPS............................. 5
Handlers : Communication par Message.................... 7
?Self.......................................................................................9
Représentation des Relations entre objets .................10
Sortes de Relations entres Objets...............................................13
Representation d'une Hiérarchie des Categories ..........................14
Représentation Structurée de la Connaissance
Séance 7
Représentation Structurée de la Connaissance
Intelligence : (Petit Robert)
"La faculté de connaître et comprendre.
On a vu que Connaissance = Compétence.
Qu'est que c'est à comprendre?
Association entre choses perçu et choses connus.
Pour comprendre une scène ou une histoire, il faut trouver une correspondance
entre les éléments perçu et les choses connus.
Idée des Schémas (et de Frames):
Les schémas (ou Frames) représentent des éléments de connaissance pour structurer
les perceptions et les histoires.
Ceci exige :
1) Une "structure" pour représenter la connaissance.
2) Une organisation de ces structures :
Techniques
Représenter la connaissance dans une hiérarchie des Schémas
(une forme de programmation Orientée Objet).
Réseau Sémantique : Un réseau des concepts lié par des associations
Frames : Un assemblage des objets pour définir un contexte.
Scripts : Un assemblage des objets pour définir une séquence des événements
Représentation Déclaratif de connaissance sur la forme des "objets"
Exemples des outils de programmation :
KRL -> KEE -> Nexpert (Intégration des Règles, Prédicates et Schémas)
-> Knowledge Craft (Intégration d'OPS-5, Prolog et "KRL").
-> COOL (CLIPS 5)
7-2
Représentation Structurée de la Connaissance
Séance 7
Pour comprendre une scène ou une histoire, il faut trouver une correspondance
entre les éléments d'une perception et les éléments qui représente les connaissances.
Les concepts de représentation de connaissance structurée et programmation
orientée objet ont évolué en parallèle dans l'IA et le génie logiciel.
L'IA :
Schémas ( Psychologie Cognitive, 1930's)
Réseau Sémantique : (Quinlan, Carbonnel 1968).
Frames : (Minsky, 1970's)
Units : (KRL 1970's)
Le Génie-logiciel :
Simula-67 (1967)
SmallTalk (Goldberg, 1973)
Flavors : Un outil "programmation par Objet" en Common Lisp.
Terminologie :
Schéma, Unit, Objet :
Une encapsulation des données et procédures.
Class, flavor : Un cadre pour définir un objet.
(mais en KEE et smalltalk c'est aussi un objet!)
Instance : Un exemplaire d'une classe.
Méthode : Une procédure dans un objet.
Demon : Une méthode "invisible" déclenchée automatiquement à l'accès à
une variable.
Servant : Une méthode visible à extérieur d'un objet.
7-3
Représentation Structurée de la Connaissance
Séance 7
Quatre Principes (+1)
1) Encapsulation : Enrobement de Connaissance déclarative et procédurale
dans un "objet".
2) Génération Dynamique des Instances des objets.
3) Héritage des valeurs et procédures dans une hiérarchie des "Classes" d'objets.
4) "Communication par Message" : Communication entre les instances d'objets.
Cinquième Principe : polymorphism;
Une fonction peut adapter sa traîtement au type d'objets
Une classe d'objets ( un schéma, ou Flavor) est défini par :
Un nom (unique),
Ses parents (les superclasses)
Ses Fils (les sous-classes et instances)
Une liste d'attributs ("slots" ou Propriété) avec leur description ("facets").
Une liste de procédures (méthodes)
Les valeurs possibles d'des attributs sont données par des "facets".
Un slot peut :
1) contenir des valeurs et listes des valeurs
2) "pointer" vers des autre objets
3) être lié à des méthodes invisibles (demons).
On peut Allouer ou détruire les instances (et même les classes) dynamiquement.
Ceci alloue et initialize les variables pour une situation.
Des classes sont des "types abstrait"...Ces attributs sont ENCAPSULER.
Leur donnée et organisation sont cachée.
On peut accéder que par des procédures d'accès : Méthodes.
Ils sont déclenchés par communication par message.
7-4
Représentation Structurée de la Connaissance
Séance 7
Définition des Classes en CLIPS
Une classe est définit par une expression :
(defclass <name> [<comment>]
(is-a <superclass-name>+)
[<role>]
[<pattern-match-role>]
<slot>*
<handler-documentation>*)
(1) A (defclass) must have a class name, <class>.
(2) There is at least one superclass name, <superclass>, that follows the is-a.
(3) A (defclass) has zero or more slots.
(4) Each slot has zero or more facets; types, <facet>, which describe the
characteristics of the slot.
Exemple :
(defclass PERSON (is-a USER) (role concrete)
(pattern-match reactive)
(slot nom (default "John Doe")
(create-accessor read-write))
(slot age (create-accessor read-write))
(multislot address (create-accessor read-write))
)
(defclass ENSI (is-a PERSON) (role concrete)
(slot year (create-accessor read-write))
(slot OPTION (default MD) (create-accessor read-write))
)
En CLIPS, une schéma est défini par un instance d'une classe
(make-instance <instance> of <class> (<slot> <value>)...)
(defclass PERSON (is-a USER)
(slot name)
(multislot address)
(slot age)
)
(make-instance [Jim] of PERSON (name "jim")(age 18))
[Jim] ; CLIPS returns the name of the instance made.
CLIPS>(send [Jim] print)
Jim of PERSON
(name "jim")
(age 18)
(address)
7-5
Représentation Structurée de la Connaissance
CLIPS>(send [Jim] get-age)
18
Séance 7
la définition d'une slot entraine le définition des "methodes":
put-<slot>
écrire une valeur
get-<slot>
lire une valeur
init-<slot>
initialiser une valeur.
Rappel que en MYCIN les "faits" était fortement typé par une structure
de donnée. Le même idéa se trouve dans le programmation orienté
objet. Les propriétés sont decrits par les "facets".
Les Classes prédefini en clips :
OBJECT
USER
PRIMITIVE
NUMBER
INTEGER
INSTANCE
ADDRESS
INITIAL-OBJECT
MULTIFIELD
FLOAT
INSTANCE-NAME
LEXEME
SYMBOL
INSTANCE-ADDRESS
FACT-ADDRESS
STRING
EXTERNAL-ADDRESS
CLIPS> (list-defclasses)
7-6
Représentation Structurée de la Connaissance
Séance 7
Handlers : Communication par Message
La Communication par Message permet d'accéder d'une valeur dans un objet
La forme général d'un message est :
(SEND OBJET METHODE ARG*)
SEND : Mot Clé pour send (par fois c'est ¨) .
OBJET : Une pointer au objet, (dit l'objet "actif").
METHODE : la méthode à appeler (Get-Value ou autre).
ARG* : Les arguments pour la méthode.
Note : Il faut avoir un pointeur sur un objet pour l'accéder!
exemple :
(make-instance [Joe] of PERSON (name "joe")(age 32))
(send [Joe] get-name)
Les METHOD's pour les objets en CLIPS sont appelés des "message-handlers".
(nota: Il existe également les fonctions "generic" composés de "methods"
en CLIPS. Ceci nous ne concerne pas dans ce cours. )
Un certain nombre de message-handlers sont définis quand une classe
est déclarée d'être "concrete". Notamment : init, print, delete.
D'autre message-handlers sont définis pour les slots déclarés
avec des "create-accessor"
Dans le BNF on trouve :
<create-accessor-facet> ::= (create-accessor ?NONE | read | write | read-write)
Accessor Facet
read
write
read-write
Message Handler Crée.
get-<slot>
put-<slot>
get-<slot> et put-<slot>
Il est possible de déclarer d'autre message handlers, ainsi de changer la définition
des message-handlers existant, avec "defmessage-handler".
7-7
Représentation Structurée de la Connaissance
Syntaxe :
Séance 7
(defmessage-handler
<class-name> <message-name>
[<handler-type>] [<comment>]
(<parameter>* [<wildcard-parameter>])
<action>*
)
<handler-type>
::= around | before | primary | after
<parameter>
::= <single-field-variable>
<wildcard-parameter> ::= <multifield-variable>
Explication
<class-name> :
<message-name> :
[handler-type] :
<parameters>:
[wildcard-parameter] :
<action>:
Nom d'une classe
Nom du message handler
Type de handler.
Variables clips
variable du type liste
Les actions ou fonctions clips
exemples :
si (create-accessor read) est déclaré :
(defmessage-handler <class> get-<slot-name> primary ()
?self:<slot-name>)
si (create-accessor write) est déclaré :
(defmessage-handler <class> put-<slot-name> primary (?value)
(bind ?self:<slot-name> ?value)
ou bien, si c'est un multi-slot :
(defmessage-handler <class> put-<slot-name> primary ($?value)
(bind ?self:<slot-name> $?value)
7-8
Représentation Structurée de la Connaissance
Séance 7
?Self
Considère : (send [OBJ] fonction)
L'objet [OBJ] est dit "actif".
Dans un message handler, la variable ?self fourni une pointer a l'objet actif.
On peut l'utiliser afin d'accéder aux slots.
Par exemple :
(defclass THING (is-a USER) (role concrete)
(slot NAME (create-accessor read-write) (default A))
)
(defmessage-handler THING ask-name ()
(send ?self get-NAME)
)
?self donne un accès direct aux slots, avec la notation : ?self:<slot-name>.
ceci permet d'éviter le mécanisme de passage à message pour l'accès .
(defmessage-handler THING return-name ()
?self:NAME
)
NOTA : il est sans intérêt de faire :
(bind ?NAME (send ?self get-NAME))
ou même
(bind ?NAME ?self:NAME)
Utilisez
(?self:NAME)
7-9
Représentation Structurée de la Connaissance
Séance 7
Représentation des Relations entre objets
Les méthodes (message handlers en CLIPS) permet de réaliser des relations entre
objets.
Par exemple, les relations les relations entre les membres d'une famille peuvent être
générées par des"handlers".
Exemple : Définition de Personne :
(defclass PERSONNE (is-a USER)
(slot nom (create-accessor read-write))
(slot pere (create-accessor read-write))
(slot mere (create-accessor read-write))
(multislot freres (create-accessor read-write))
(multislot soeurs (create-accessor read-write))
)
(defclass HOMME (is-a PERSONNE ) (role concrete)
(slot epouse (create-accessor write))
(slot sexe (access read-only)(default masculin)
(create-accessor read))
)
(defclass FEMME (is-a PERSONNE ) (role concrete)
(slot epoux (create-accessor write))
(slot sexe (access read-only)(default feminin)
(create-accessor read))
)
Des "message-handlers" pour la classe PERSONNE qui déterminent la "gandmere"
et le "grandpere" paternels sont :
(defmessage-handler PERSONNE grandpere-paternale ()
(send ?self:pere get-pere)
)
(defmessage-handler PERSONNE grandmere-paternale ()
(send ?self:pere get-mere)
)
Note qu'il s'agit des pointers vers les grandpere (meres)
Des "message-handlers" pour la classe PERSONNE qui déterminent les noms sont :
7-10
Représentation Structurée de la Connaissance
(defmessage-handler PERSONNE grandpere-paternale ()
(send (send ?self:pere get-pere) get-nom)
)
Séance 7
(defmessage-handler PERSONNE grandmere-paternale ()
(send (send ?self:pere get-mere) get-nom)
)
(defmessage-handler PERSONNE grandpere-maternale ()
(send (send ?self:mere get-pere) get-nom)
)
(defmessage-handler PERSONNE grandmere-maternale ()
(send (send ?self:mere get-mere) get-nom)
)
tester avec :
(make-instance [Bernard] of HOMME (nom Bernard))
(make-instance [Emma] of FEMME (nom Emma))
(make-instance [Albert] of HOMME (nom Albert))
(make-instance [Josephte] of FEMME (nom Josephte))
(make-instance [Stephen] of HOMME (nom Stephen)
(pere [Bernard]) (mere [Emma]))
(make-instance [Cecile] of FEMME (nom Cecile)
(pere [Bernard]) (mere [Emma]))
(make-instance [Jerome] of HOMME (nom Jerome)
(pere [Albert]) (mere [Josephte]) (freres [Stephen]))
(make-instance [Eric] of HOMME (nom Eric)
(pere [Jerome]) (mere [Cecile]))
(send [Eric] grandpere-paternale)
(send [Eric] grandmere-paternale)
(send [Eric] grandpere-maternale)
(send [Eric] grandmere-maternale)
7-11
Représentation Structurée de la Connaissance
Séance 7
Le message handler pour la classe PERSONNE qui détermine les addresses des
oncles (freres du pere et freres de la mere).
(defmessage-handler PERSONNE oncles ()
(create$ (send ?self:pere get-freres)
(send ?self:mere get-freres)
)
)
Le message-handler pour la classe PERSONNE qui détermine la liste des noms de
tous les grands-parents.
(defmessage-handler PERSONNE
(create$
(send (send ?self:pere
(send (send ?self:pere
(send (send ?self:mere
(send (send ?self:mere
)
)
grand-parents ()
get-pere)
get-mere)
get-pere)
get-mere)
get-nom)
get-nom)
get-nom)
get-nom)
7-12
Représentation Structurée de la Connaissance
Séance 7
Sortes de Relations entres Objets
Les liaisons de relations peuvent décrire structure (exemple : above, below, beside)
ou relations d’une famille (exemple : mother, father, sister, brother)
ou relations de temps (exemple : après, avant, pendant).
La “Valence” ou “Arité” d’une relation est le nombre de choses associé par cette
relation.
Monadic ou unaire:
diadic (ou binaire):
triadic (ou ternaire) :
male(Jim)
instance-of (Jim, person)
action (Jim, flew, AF357)
Les relations monadic sont les propriétés. Ils peuvent être représenté par
la valeur dans un slot.
Les relations diadic associe deux objets. Ils peuvent être représenté par
un pointer dans un slot.
Les relations tiadic exige un noeud (un objet) avec les pointers pour les rôles.
Il existe une démonstration que toute relation peut être exprimé par
un ensemble des relations unaire, binaire ou ternaire.
Les liaisons de relations dans un FRAME peuvent décrire la structure
(exemple : above, below, beside)
ou relations d’une famille (exemple : mother, father, sister, brother)
ou relations de temps (exemple : après, avant, pendant).
Exemple : Un symbole est une relation triadic entre
une chose, un signe et une agent (un interprète)
(defclass symbol (is-a USER)
(slot signe)
(slot chose)
(slot agent)
)
7-13
Représentation Structurée de la Connaissance
Representation d'une Hiérarchie des Categories
Séance 7
Les objets peuvent représenter les concepts organisé en Catégories.
Les catégories formes une “hiérarchie de concepts”.
Ceci permet une inférence des propriétés (par défaut)
et une économie de représentation.
La relation d’abstraction ENTRE catégories est appelée “AKO” (A Kind of).
Nous allons faire une inférence entre membres de cette hiérarchie
par une sorte d'“héritage dynamique”.
Héritage simple : Une AKO par classe
Héritage multiple : Plusieurs AKO par classe.
Exemple:
(defclass CHOSE (is-a USER) (role concrete)
(multislot AKO (create-accessor read-write))
(slot couleur (create-accessor read-write))
)
(make-instance [A] of CHOSE (AKO [B] [C]))
(make-instance [B] of CHOSE (AKO [D] [E]))
(make-instance [C] of CHOSE (couleur bleu))
(make-instance [D] of CHOSE (couleur blanc))
(make-instance [E] of CHOSE (couleur rouge))
E
D
AKO:
AKO:
Couleur: rouge
Couleur: blanc
B
C
AKO : D E
AKO:
Couleur: NIL
Couleur: bleu
A
AKO : B C
Couleur: NIL
7-14
Représentation Structurée de la Connaissance
Séance 7
L’héritage dynamique est une forme de parcours de graphe.
Il peut être multiple. Il peut être “strict” ou “defeasible”.
Héritage multiple “defeasible” permet les exceptions.
La Relation AKO est réaliser par une “message-handler”.
(defmessage-handler CHOSE inherit-couleur ()
(if (neq ?self:couleur nil) then
(return ?self:couleur)
else
(bind ?couleur)
(progn$ (?super ?self:AKO)
(bind ?couleur (send ?super inherit-couleur))
(if (neq nil ?couleur) then (break))
)
(return ?couleur)
)
)
Une message-handler pour une héritage multiple est
;;
;; héritage multiple. Les valeurs sont aussi affecté aux slots.
;;
(defmessage-handler CHOSE mv-inherit-couleur ()
(if (neq ?self:couleur nil) then
(return ?self:couleur)
else
(bind $?couleur (create$))
(progn$ (?super ?self:AKO)
(bind ?c (send ?super inherit-couleur))
(if (neq ?c nil) then
(bind $?couleur (insert$ $?couleur 1 ?c))
)
)
(return $?couleur)
)
)
7-15
Représentation Structurée de la Connaissance
Séance 7
7-16