Le système CLIPS Systèmes à Base de Connaissances

Présentation au sujet: "Le système CLIPS Systèmes à Base de Connaissances"— Transcription de la présentation:

1 Le système CLIPS Systèmes à Base de Connaissances
Représentation des connaissances Représentation des faits Représentation des règles Programmation fonctionnelle Moteur d’inférences Compilation de la base de règles Stratégies de résolution de conflits Ce document n’est pas un manuel de référence mais un support de cours La documentation CLIPS est téléchargeable sur le site web suivant :

2 Rappels Problématique : Méthode :
Pas toujours facile (ni même possible) d’exprimer la manière de résoudre un problème en décrivant un algorithme On cherche à simuler le raisonnement humain dans les domaines où les connaissances sont évolutives et dans lequel il n’existe pas de méthode sûre ou déterministe : Exemple de la finance, de l’économie, des sciences sociales Exemple de la médecine (diagnostic médical), de la maintenance Exemple de la démonstration automatique de théorèmes, … Méthode : Isoler et modéliser un sous-ensemble du monde réel Poser le problème en termes de faits initiaux ou de but à atteindre Lancer un programme qui simule le raisonnement humain

3 Connaissances d’un SBC
Partie déclarative : Fait : connaissance déclarative (information) sur le monde réel Règle : connaissance déclarative de gestion de la base de faits En logique monotone : uniquement ajouts de faits En logique non-monotone : ajouts, modifications et retraits de faits Partie algorithmique : Moteur d’inférences : composant logiciel qui effectue des raisonnements sur la connaissance déclarative dont il dispose : Applique les règles de la base de règles aux faits de la base de faits Fondé sur une ou plusieurs règles d’inférences (ex : déduction) La trace du raisonnement peut être consultée : Durant les phases de conception ou de débuggage Pour obtenir des explications sur la résolution

4 ajouts / modifications / suppressions
Architecture d’un SBC Base de faits : Contient les faits initiaux, puis les faits déduits Base de règles : Contient les règles qui exploitent les faits Moteur d’inférences : Applique les règles aux faits ajouts / modifications / suppressions Faits faits initiaux Règles règles du domaine autres actions règles d’inférence

5 Exemple de la déduction
Modus Ponens Modus Tollens Inférences sans variable : (homme Socrate) est vrai (homme Socrate) ® (mortel Socrate) (mortel Socrate) est vrai (mortel McLeod) est faux (homme McLeod) ® (mortel McLeod) (homme McLeod) est faux Inférences avec variables : (homme Socrate) est vrai (homme ?x) ® (mortel ?x) Substs : { ?x = Socrate } (mortel Socrate) est vrai (mortel McLeod) est faux (homme ?x) ® (mortel ?x) Substs : { ?x = McLeod } (homme McLeod) est faux

6 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

7 Le système CLIPS 6.10 Un environnement de développement complet :
Caractéristiques : Trois formalismes de représentation des connaissances Moteur d’ordre 1 fonctionnant en chaînage avant (Modus Ponens) Implémentation en langage C de l’algorithme RETE (efficacité) Langage de commande et de programmation de type Lisp Modes de commande : Mode batch (le système est lancé avec un fichier de commandes) Mode ligne de commande (seulement pour les amateurs) Interface graphique multi-fenêtrée (Windows, Macintosh, Unix) La cerise sur le gâteau : Logiciel libre écrit en langage C (code lisible et documenté) Une communauté de développeurs CLIPS plutôt active Des sites Web, des extensions, une liste de distribution

8 Bref historique CLIPS (C-Language Integrated Production System) :
1985 : release 1.0 (prototype) Artificial Intelligence Section — Lyndon B. Johnson Space Center Implémentation en C du moteur d’inférences le plus efficace : OPS 5 1986 : release 3.0 (première diffusion officielle) 1991 : release 5.0 (aspects procéduraux + COOL) La couche objet s’inspire de CLOS (Common Lisp Object System) 1993 : release 6.0 (modules + filtrage des objets COOL) 1998 : release 6.1 (user functions + profiler + compatibilité C++) Les « produits dérivés » : JESS (the Java Expert System Shell) : Version Java de CLIPS CAPE (CLIPS and Perl with Extensions) : Intégration de Perl WebCLIPS : Version CGI pour serveurs HTTP FuzzyCLIPS : Pour les amateurs de logique floue

9 Interface graphique

10 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

11 Gestion de la BDF Ajouter un fait dans la BDF :
CLIPS> (assert (homme Socrate)) <fact-0> CLIPS> (assert (mortel Socrate)) <fact-1> Retirer un fait de la BDF : CLIPS> (retract 0)

12 Déduction sans variable
Règle qui ajoute un fait dans la BDF : (defrule deduction-1 "Cette règle réalise un Modus Ponens sans variable"  (homme Socrate) => (assert (mortel Socrate)))

13 Déduction avec variable
Règle qui ajoute un fait dans la BDF : (defrule deduction-2 "Cette règle réalise un Modus Ponens avec variable" (homme ?x) => (assert (mortel ?x)))

14 Syntaxe des faits Fait ordonné ou pattern : Exemples de patterns :
Liste constituée d’un symbole (la relation) suivi d’une séquence (éventuellement vide) de données séparées par des espaces Une donnée doit être de l’un des huit types CLIPS (voir typologie) Un symbole est une séquence de n’importe quels caractères ASCII à l’exception des caractères suivants : ( ) < > & $ | ; ? ~ Les faits CLIPS n’acceptent pas de caractères accentués ! Exemples de patterns : (flag) (homme Socrate) (adresse Dupont "99 rue des Mésanges, Groland") (statut pompe active) (sorte-de Walibi Marsupial) (personnes Pierre Paul Jacques Marie)

15 Syntaxe des règles Constructeur de règles :
Constitué d’une séquence de conditions suivie d’une séquence d’actions à exécuter si toutes les conditions sont vérifiées : Les filtres ou pattern-conditional elements : Permet le filtrage des faits ou pattern-matching Structure qui contient des constantes, des jokers et des variables : Constante : donnée symbolique ou (alpha-) numérique Joker (wildcard) : monovalué ( ? ) ou multivalué ( $? ) Variable : monovaluée ( ?toto ) ou multivaluée ( $?toto ) (defrule <identificateur> [commentaire] ; Chaîne de caractères <filtre>* ; LHS (Left-Hand Side) => <action>*) ; RHS (Right-Hand Side)

16 Principe du filtrage Filtrage des faits ou pattern matching :
Consiste à comparer un filtre avec les faits de la base de faits : Les constantes ne sont égales qu’à elles-mêmes Les jokers absorbent les données rencontrées Les variables libres s’apparient aux données rencontrées Les variables liées comparent leur valeur aux données rencontrées Exemple : Soit la base de faits suivante : Soient les règles suivantes : (defrule test1 (statut ?element active) =>) (defrule test3 (statut ?element ouverte) (alerte ? non) =>) (defrule test2 (statut ?element ouverte) (alerte ?element non) =>) (defrule test4 (statut $?etat) =>)

17 Règle déclenchable Définition :
Règle dont toutes les conditions (LHS) sont vérifiées Une activation réuni une règle déclenchable et les faits concernés Les activations sont placées dans une file appelée agenda La règle « test1 » est déclenchable avec le fait n°1 La règle « test1 » est déclenchable avec le fait n°4 La règle « test3 » est déclenchable avec les faits n°2 et n°3 La règle « test4 » est déclenchable avec le fait n°1 La règle « test4 » est déclenchable avec le fait n°2 La règle « test4 » est déclenchable avec le fait n°4 pompe.clp

18 Agenda de tâches Faits Règles Principe :
Maintenir une file d’attente (ordonnée) d’activations Faits Rule : R034 Priority : 10 Substs : { } Règles - Initialiser l’agenda - Tant qu’il reste des tâches dans l’agenda : - Effectuer la première tâche - Mettre à jour l’agenda : - Supprimer les tâches obsolètes - Insérer les nouvelles tâches

19 Dépendance logique Problème de la non-monotonie : Solution proposée :
Des faits supprimés peuvent rendre la BDF incohérente On souhaite maintenir la cohérence logique de la BDF Solution proposée : Décrire un graphe de dépendances entre des faits conditionnels et les faits déduits (si un fait est supprimé, cela doit pouvoir déclencher une série de suppressions en chaîne) Les filtres avec dépendance logique doivent figurer en tête : Exemple du frigo : (defrule interrupteur "Une règle d’extinction n’est plus nécessaire" (logical (refrigerator door open)) => (assert (refrigerator light on)))

20 Dépendance logique CLIPS> (assert (refrigerator door open)) ==> f (refrigerator door open) ==> Activation interrupteur: f-1 <Fact-1> CLIPS> (run) FIRE interrupteur: f-1 ==> f (refrigerator light on) CLIPS> (retract 1) <== f (refrigerator door open) <== f (refrigerator light on) Attention c’est un peu plus compliqué qu’il n’y paraît ! Voir exemple dans le Basic Programming Guide page 55 A utiliser avec précaution et parcimonie !

21 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

22 Le monde des cubes On veut écrire la partie « I.A. » d’un robot mobile : Le robot doit effectuer des actions en fonction de connaissances sur son environnement et d’un but qui lui est donné Ses actions doivent être le résultat d’un raisonnement (IA) Une action doit modifier la représentation (modèle) du monde Ce logiciel sera fondé sur une base de connaissances : Connaissances du robot : Connaissances sur le monde et sur lui-même Implémentées à l’aide de faits stockés dans la base de faits Raisonnement du robot : Un but peut donner lieu à une série de sous-buts et d’actions (planification) Implémenté à l’aide de règles portant sur les faits

23 LMDC v1.0 (analyse) Raisonnement de type planification :
Pour déposer un objet A sur un objet B, il faut posséder l’objet A et être à proximité de l’objet B Pour posséder un objet, il faut prendre cet objet Pour prendre un objet, il faut être à proximité de cet objet Pour être à proximité d’un objet, il faut aller vers cet objet but 1 Déposer A sur B 2 but but but Posséder A Être à proximité de B Aller vers B but but but Prendre A Être à proximité de A Aller vers A

24 LMDC v1.0 (analyse) Les actions du robot :
Action : déposer un objet A sur un objet B Conséquence : l’objet A est sur l’objet B Condition : posséder l’objet A Condition : être à proximité de l’objet B Action : prendre un objet Conséquence : possession de l’objet Condition : être à proximité de l’objet Action : aller vers un objet Conséquence : être à proximité de l’objet

25 LMDC v1.0 (analyse) Les règles de décomposition :
But : déposer un objet A sur un objet B Sous-but : posséder l’objet A Sous-but : être à proximité de l’objet B But : posséder un objet Sous-but : prendre l’objet But : prendre un objet Sous-but : être à proximité de l’objet But : être à proximité d’un objet Sous-but : aller vers l’objet

26 LMDC v1.0 (codage) (defrule action-deposer
(but deposer ?objet1 ?objet2) (possede ?objet1) (proximite ?objet2) => (printout t "Je dépose " ?objet1 " sur " ?objet2 crlf) (assert (sur ?objet1 ?objet2))) (defrule action-prendre (but prendre ?objet) (proximite ?objet) (printout t "Je prends " ?objet crlf) (assert (possede ?objet))) (defrule action-aller-vers (but aller-vers ?objet) (printout t "Je vais vers " ?objet crlf) (assert (proximite ?objet)))

27 LMDC v1.0 (codage) Règles de décomposition :
Fait initial (dans la base de faits dès le début) : (deffacts init (but deposer cube-A cube-B)) (defrule decompose-deposer (but deposer ?objet1 ?objet2) => (assert (but proximite ?objet2))) (assert (but possede ?objet1))) (defrule decompose-prendre (but prendre ?objet) (assert (but proximite ?objet))) (defrule decompose-proximite (but proximite ?objet) => (assert (but aller-vers ?objet))) (defrule decompose-possede (but possede ?objet) (assert (but prendre ?objet)))

28 LMDC v1.0 (tests) Chargement et exécution du code 1.0 :
Que penser de la base de faits après l’exécution ? cubes1.clp

29 LMDC v1.1 (analyse) Modification du code :
On veux supprimer les buts devenus obsolètes qui peuvent perturber le processus de planification Comment supprimer un fait dans le RHS d’une règle ? On mémorise son fact-address dans une variable On fait un retract en lui passant l’adresse du fait : (defrule <identificateur> ... <variable> <- <filtre> ; Mémorisation => (retract <variable>) ; Suppression ... )

30 LMDC v1.1 (codage) (defrule action-deposer
?p <- (but deposer ?objet1 ?objet2) (possede ?objet1) (proximite ?objet2) => (printout t "Je dépose " ?objet1 " sur " ?objet2 crlf) (assert (sur ?objet1 ?objet2)) (retract ?p)) (defrule action-prendre ?p <- (but prendre ?objet) (proximite ?objet) (printout t "Je prends " ?objet crlf) (assert (possede ?objet)) (defrule action-aller-vers ?p <- (but aller-vers ?objet) (printout t "Je vais vers " ?objet crlf) (assert (proximite ?objet))

31 LMDC v1.1 (codage) Règles de décomposition :
Pourquoi ne pas retirer les buts des règles décompose-déposer et décompose-prendre ? (defrule decompose-deposer (but deposer ?objet1 ?objet2) => (assert (but proximite ?objet2)) (assert (but possede ?objet1))) (defrule decompose-prendre (but prendre ?objet) (assert (but proximite ?objet))) (defrule decompose-proximite ?p <- (but proximite ?objet) => (assert (but aller-vers ?objet)) (retract ?p)) (defrule decompose-possede ?p <- (but possede ?objet) (assert (but prendre ?objet))

32 LMDC v1.1 (tests) Chargement et exécution du code 1.1 :
Que penser de la base de faits après l’exécution ? cubes2.clp

33 LMDC v1.2 (analyse) Encore deux bugs : Modification du code :
Quand le robot va vers le cube B, il reste à proximité du cube A Quand le robot dépose le cube A, il le possède toujours Modification du code : Il faut supprimer le fait (possede ?objet1) dans le RHS de la règle action-déposer Il faut supprimer le fait (proximite ?) dans le RHS de la règle action-aller-vers Que faire s’il n’y a pas de fait « proximité » dans le base de faits ? Tester l’absence d’un fait dans le LHS d’une règle : Condition d’absence : (not <filtre>)

34 LMDC v1.2 (codage) (defrule action-deposer
?p <- (but deposer ?objet1 ?objet2) ?q <- (possede ?objet1) (proximite ?objet2) => (printout t "Je dépose " ?objet1 " sur " ?objet2 crlf) (assert (sur ?objet1 ?objet2)) (retract ?p ?q)) (defrule action-aller-vers-1 ?p <- (but aller-vers ?objet) (not (proximite ?)) (printout t "Je vais vers " ?objet crlf) (assert (proximite ?objet)) (retract ?p)) (defrule action-aller-vers-2 ?q <- (proximite ?)

35 LMDC v1.2 (tests) Chargement et exécution du code 1.2 :
Peut-on encore améliorer le programme ? cubes3.clp

36 LMDC v1.3 (analyse) Encore quelques petits problèmes :
On suppose que le robot doit systématiquement s’approprier les objets : le robot pourrait déjà posséder l’objet A ! Il faut vérifier que le robot ne possède pas déjà l’objet à déposer dans la décomposition de l’action déposer On suppose que le robot doit systématiquement se rapprocher des objets : le robot pourrait déjà être à proximité de l’objet B ! Il faut vérifier que le robot n’est pas déjà à proximité de l’objet à déposer dans la décomposition de l’action déposer Comme il faut traiter ces deux cas indépendamment l’un de l’autre, il faut deux règles pour décomposer l’action déposer Plus généralement, il faut s’assurer de ne pas recréer des situations qui existent déjà…

37 LMDC v1.3 (codage) Décomposition du but « déposer-sur »
(defrule decompose-deposer-1 (but deposer ?objet1 ?objet2) (not (possede ?objet1)) => (assert (but possede ?objet1))) (defrule decompose-deposer-2 (not (proximite ?objet2)) (assert (but proximite ?objet2))) (defrule decompose-prendre (but prendre ?objet) (not (proximite ?objet)) (assert (but proximite ?objet))) Décomposition du but « déposer-sur »

38 LMDC v1.3 (tests) L’ordre des règles est-il important ? cubes4.clp

39 LMDC v1.3 (tests) Examinons la trace des inférences :
Le robot aurait dû déclencher la règle « action-prendre » ==> f (but deposer cube-A cube-B) CLIPS> (run) FIRE 1 decompose-deposer-2: f-1, ==> f (but proximite cube-B) FIRE 2 decompose-proximite: f-2 ==> f (but aller-vers cube-B) <== f (but proximite cube-B) FIRE 3 action-aller-vers-1: f-3, Je vais vers cube-B ==> f (proximite cube-B) <== f (but aller-vers cube-B) FIRE 4 decompose-deposer-1: f-1, ==> f (but possede cube-A) FIRE 5 decompose-possede: f-5 ==> f (but prendre cube-A) <== f (but possede cube-A) FIRE 6 decompose-prendre: f-6, ==> f (but proximite cube-A) FIRE 7 decompose-proximite: f-7 ==> f (but aller-vers cube-A) <== f (but proximite cube-A) FIRE 8 action-aller-vers-2: f-8,f-4 Je vais vers cube-A ==> f (proximite cube-A) <== f (but aller-vers cube-A) <== f (proximite cube-B) FIRE 9 decompose-deposer-2: f-1, ==> f (but proximite cube-B) FIRE 10 decompose-proximite: f-10 ==> f (but aller-vers cube-B) <== f (but proximite cube-B) FIRE 11 action-aller-vers-2: f-11,f-9 Je vais vers cube-B Le robot aurait dû déclencher la règle « decompose-deposer-1 »

40 LMDC v1.4 (analyse) Problèmes :
Cycle n°1 : le robot commence par rechercher la proximité du cube B avant de s’assurer qu’il possède l’objet A A priorité égale, les règles sont prise en compte du haut vers le bas Cycle n°9 : le robot se préoccupe du but déposer alors qu’il devrait déclencher la règle action-prendre sur le cube A La règle est déclenchable mais se trouve en seconde position dans l’agenda Commençons par donner une priorité supérieure aux règles d’action devant les règles de décomposition (defrule <identificateur> (declare (salience <entier>)) ...

41 LMDC v1.4 (tests) Chargement et exécution du code 1.4 :
Cela ne boucle plus mais il faut quand-même inverser les deux règles decompose-deposer-1 et decompose-deposer-2 cubes5a.clp cubes5b.clp

42 Quelques commandes de base
Commande (clear) : Vide les bases de connaissances (faits et règles) et l’agenda Commande (load <fichier>) : Charge un fichier de constructeurs (deffacts, defrule, etc.) Commande (reset) : Vide la base de faits, crée un fait (initial-fact), crée les faits déclarés avec le constructeur deffacts et initialise l’agenda Commande (run) : Lance le moteur d’inférences jusqu’à ce que l’agenda soit vide Commande (facts) : Affiche une représentation de la base de faits (sortie standard) Commande (agenda) : Affiche une représentation de l’agenda (sortie standard)

43 La ligne de commande CLIPS> (load "cubes5b.clp")
Defining deffacts: init Defining defrule: action-deposer +j+j+j Defining defrule: action-prendre +j+j ... TRUE CLIPS> (facts) CLIPS> (agenda) CLIPS> (reset) f (initial-fact) f (but deposer cube-A cube-B) For a total of 2 facts. decompose-deposer-1: f-1, decompose-deposer-2: f-1, For a total of 2 activations. CLIPS> (run) Je vais vers cube-A Je prends cube-A Je vais vers cube-B Je dépose cube-A sur cube-B CLIPS> (facts) f (initial-fact) f (proximite cube-B) f (sur cube-A cube-B) For a total of 3 facts. CLIPS> (agenda) CLIPS> (clear) CLIPS> (reset) CLIPS> (exit)

44 Commandes de débuggage
Utilisées pour obtenir une trace des inférences : (watch <item>) permet d’ajouter une information à tracer (unwatch <item>) permet d’enlever une information tracée (dribble-on <file>) envoie la trace vers un fichier texte (dribble-off) ferme le fichier de trace CLIPS> (reset) CLIPS> (watch rules) CLIPS> (watch facts) CLIPS> (watch activations) CLIPS> (run) FIRE 1 decompose-deposer-1: f-1, ==> f (but possede cube-A) ==> Activation decompose-possede: f-2 FIRE 2 decompose-possede: f-2 ==> f (but prendre cube-A) ==> Activation decompose-prendre: f-3, <== f (but possede cube-A)

45 Remarque sur le « not » Pourquoi la règle suivante n’est-elle pas déclenchée ? Une condition de type (not(B)) est traitée comme : (A)(not(B)) où (A) est la condition précédente (initial-fact)(not(B)) On aurait aussi pu inverser les deux conditions CLIPS> (clear) CLIPS> (defrule exemple (not (toto)) (titi) => (printout t "coucou" crlf)) CLIPS> (assert (titi)) CLIPS> (run) CLIPS> (defrule exemple (initial-fact) (not (toto)) (titi) => (printout t "coucou" crlf)) 

46 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

47 Limites des faits ordonnés
Les faits ordonnés (listes) : Avantage : peuvent être utilisés sans déclaration préalable Inconvénient : aucun contrôle sur le type des données Inconvénient : peu explicite (source d’erreurs potentielles) Attention : la position d’une donnée peut avoir de l’importance ! (employe "Dupond" "Jacques" 27 CDD) (employe "Jacques" "Dupond" CDD 27) On voudrais pouvoir typer davantage les données On vaudrais pouvoir manipuler des données sans se soucier d’une position dans une liste Différents !

48 Les faits structurés Fait structuré ou template : Avantages :
Structure de type enregistrement qui permet de spécifier et d’accéder à des attributs (slots) appartenant à des faits Les templates doivent être déclarés avant d’être utilisés ! L’ordre des attributs n’a pas d’importance les attributs peuvent être monovalués ou multivalués Un attribut multivalué se manipule comme un fait ordonné (liste) On peut spécifier un domaine pour chaque attribut : Type, intervalle, cardinal, valeur par défaut, etc. Avantages : Beaucoup plus explicites que les faits ordonnés Contrôle possible du type des données

49 Les faits structurés Exemple n°1 :
(deftemplate employe "Les employés de ma petite entreprise" (slot nom (type STRING)) (slot prenom (type STRING)) (slot age (type INTEGER)) (slot type-contrat (allowed-values CDD CDI) (default CDD))) CLIPS> (assert (employe (prenom "Jacques") (nom "Dupond") (age 27)))) <fact-0>

50 Les faits structurés Exemple n°2 :
(deftemplate bidule "Les bidules compliqués"  (slot nom (type SYMBOL) (default ?NONE)) (slot id (default-dynamic (gensym))) (slot loc (type SYMBOL) (default ?DERIVE)) (slot poids (allowed-values leger lourd) (default leger)) (multislot pointeurs (type FACT-ADDRESS) (default ?DERIVE))) CLIPS> (assert (bidule)) [TMPLTRHS1] Slot nom requires a value because of its (default ?NONE) attrib CLIPS> (assert (bidule (nom cube))) <fact-0> CLIPS> (assert (bidule (nom bloc) (poids lourd)) <fact-1> CLIPS> (facts) f-0 (bidule (nom cube) (id gen1) (loc nil) (poids leger) (pointeurs)) f-1 (bidule (nom bloc) (id gen2) (loc nil) (poids lourd) (pointeurs)) For a total of 2 facts.

51 Syntaxe BNF de deftemplate
(deftemplate <deftemplate-name> [<comment>] <slot-definition>*) <slot-definition> ::= <single-slot-def> | <multislot-def> <single-slot-def> ::= (slot <slot-name> <template-attrib>*) <multislot-def> ::= (multislot <slot-name> <template-attrib>*) <template-attrib> ::= <default-attrib> | <constraint-attrib> <default-attrib> ::= (default ?DERIVE | ?NONE | <expression>*) | (default-dynamic <expression>*) <constraint-attrib> ::= (type <allowed-type>+) | (allowed-values <value>+) | (allowed-symbols <symbol>+) | (range <number> <number>) | (cardinality <integer> <integer>)

52 Typologie des données Seules valeurs possibles de <allowed-type> lors de la spécification du type d’un attribut : INTEGER : nombres entiers relatifs FLOAT : nombres à virgule flottante (notation habituelle) STRING : chaînes de caractères (notation habituelle) SYMBOL : symboles (séquences insécables de caractères) FACT-ADDRESS : pointeurs pour accéder directement aux faits INSTANCE-NAME : noms des objets de la couche COOL INSTANCE-ADDRESS : pointeurs pour accéder aux objets EXTERNAL-ADDRESS : pointeurs de données externes

53 Le monde des cubes II Ils sont de retour, et bien décidés à se venger ! On voudrait avoir un groupe de robots de même type On voudrait affiner la description des robots, des objets et de l’environnement (aller vers une topologie des lieux) : L’environnement est une configuration de salles (hangar, entrepôt, etc.) Un objet doit être soit dans une salle, soit transporté par un robot A terme, ce serait bien que les robots puissent communiquer et coopérer (agir sans compétition) à une tâche collective Ce problème n’est pas traité dans ce cours mais vous êtes libres d’y penser !

54 LMDC v2.0 (analyse) Adaptons le « modèle du monde » :
Un objet possède un « id » et une localisation (salle ou robot) Un robot possède un « id » et une localisation (salle) Pour simplifier, on va considérer que la notion de « proximité » correspond à la notion de « même localisation » Un robot peut déplacer plusieurs objets en même temps Le robot possède un objet lorsque la localisation de l’objet est le robot (deftemplate objet (slot id (type SYMBOL) (default ?NONE)) (slot localisation (type SYMBOL) (default entrepot))) (deftemplate robot (slot localisation (type SYMBOL) (default hangar)))

55 LMDC v2.0 (codage) Exemple de règle d’action (action déposer) :
(defrule action-deposer (declare (salience 5)) ?but <- (but ?id-robot deposer ?id-objet1 ?id-objet2) ;; Le robot possède l’objet1 ?objet1 <- (objet (id ?id-objet1) (localisation ?id-robot)) ;; Le robot et l’objet2 sont dans le même lieu (robot (id ?id-robot) (localisation ?lieu)) (objet (id ?id-objet2) (localisation ?lieu)) => (printout t ?id-robot " dépose " ?id-objet1 " sur " ?id-objet2 crlf) ;; L’objet1 change de localisation (modify ?objet1 (localisation ?lieu)) ;; Le but est atteint (assert (sur ?id-objet1 ?id-objet2)) (retract ?but)) Modification de la valeur d’un attribut

56 LMDC v2.0 (codage) Modification d’un fait structuré (commande modify) : Exemple de règle de décomposition (but prendre) : (modify <fact-adress> (<attribut> <valeur>)+ ) (defrule decompose-prendre (but ?id-robot prendre ?id-objet) ;; Le robot n’est pas à proximité de l’objet (objet (id ?id-objet) (localisation ?lieu)) (robot (id ?id-robot) (localisation ~?lieu)) => ;; Le robot doit être à proximité de l’objet (assert (but ?id-robot proximite ?id-objet))) Contrainte « différent de »

57 LMDC v2.0 (tests) Chargement et exécution du code 2.0 : cubes6.clp

58 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

59 Manipulation des listes
En CLIPS, la représentation des connaissances repose essentiellement sur les listes : Les faits ordonnés sont des listes Les valeurs des attributs multivalués sont des listes Attention : le premier élément d’une liste a un statut particulier Nouveau problème : On veux fabriquer une liste de valeurs à partir de faits isolés L’ordre des valeurs n’a pas d’importance pour l’instant Si la liste « réceptrice » n’existe pas dans la BDF, il faudra la créer (data 12) (data 3) (data 7) (data 10) (liste )

60 Manipulation des listes
Création d’une nouvelle liste : S’il y a un fait « data » et s’il n’y a pas de fait « liste » Alors créer un fait liste avec la valeur du fait « data » Ajout d’une valeur dans une liste existante : S’il y a un fait « data » et un fait « liste » Alors ajouter la valeur du fait « data » à la fin du fait « liste » (defrule cree-liste ?donnee <- (data ?valeur) (not (liste $?)) => (retract ?donnee) (assert (liste ?valeur))) (defrule ajoute-valeur ?donnee <- (data ?valeur) ?liste <- (liste $?contenu) => (retract ?donnee ?liste) (assert (liste ?contenu ?valeur)))

61 Manipulation des listes
Recherche d’une valeur dans une liste : La valeur à rechercher est indiquée dans un fait « chercher » Suppression d’une valeur dans une liste : La valeur à rechercher est indiquée dans un fait « supprimer » (defrule recherche-valeur ?but <- (chercher ?valeur) (liste $? ?valeur $?) => (retract ?but) (printout t "je trouve " ?valeur crlf)) (defrule supprime-valeur ?but <- (supprimer ?valeur) ?liste <- (liste $?avant ?valeur $?apres) => (retract ?but ?liste) (assert (liste ?avant ?apres)))

62 Manipulation des listes
On veux connaître la position d’une valeur : Adaptons la règle « recherche-valeur » : (defrule recherche-valeur ?but <- (chercher ?valeur) (liste $? ?valeur $?) => (retract ?but) (printout t "je trouve " ?valeur crlf)) (defrule recherche-valeur-pos ?but <- (chercher ?valeur) (liste $?avant ?valeur $?) => (retract ?but) (printout t "position : " (+ (length$ ?avant) 1) crlf)) Fonction sur les listes

63 Fonctions sur les listes
Déclaration d’une variable globale (defglobal ?*liste* = (create$ a b c d)) ?*liste*  (a b c d) (create$ a b c d)  (a b c d) (length$ ?*liste*)  4 (first$ ?*liste*)  (a) (rest$ ?*liste*)  (b c d) (nth$ 2 ?*liste*)  b (member$ b ?*liste*)  2 (insert$ ?*liste* 2 #)  (a # b c d) (insert$ ?*liste* 2 ?*liste*)  (a a b c d b c d) (delete$ ?*liste* 2 3)  (a d) (subseq$ ?*liste* 2 3)  (b c) (replace$ ?*liste* 2 3 #)  (a # d) (subsetp (create$ b c) ?*liste*)  TRUE (implode$ ?*liste*)  "a b c d" (explode$ "a b c d")  (a b c d)

64 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

65 Autres fonctions Fonctions sur les chaînes : Fonctions arithmétiques :
(str-cat <expr>*), (sub-string <int> <int> <expr>), (str-index <expr> <expr>), (str-compare <expr> <expr>), (str-length <expr>), (upcase <expr>), (lowcase <expr>)... Fonctions arithmétiques : (+ <expr> <expr>+), (- <expr> <expr>+), (* <expr> <expr>+), (/ <expr> <expr>+), (div <expr> <expr>), (mod <expr> <expr>), (** <expr> <expr>), (exp <expr>), (log <expr>), (max <expr>+), (min <expr>+), (abs <expr>), (sqrt <expr>)... Fonctions trigonométriques (25) : (sin <expr>), (cos <expr>), (tan <expr>), (sinh <expr>)... Transtypage et conversion : (float <expr>), (integer <expr>), (deg-rad <expr>), (rad-deg <expr>)...

66 Prédicats Fonctions qui retournent TRUE ou FALSE Prédicats de type :
Utilisables avec la condition « test » dans les LHS Utilisables avec les commandes « if » et « while » dans les RHS Prédicats de type : (numberp <expr>), (integerp <expr>), (floatp <expr>), (stringp <expr>), (symbolp <expr>), (multifieldp <expr>)... Prédicats de comparaison : (eq <expr> <expr>+), (neq <expr> <expr>+), (= <expr> <expr>+), (> <expr> <expr>+), (>= <expr> <expr>+)... Prédicats booléens : (and <expr>+), (or <expr>+), (not <expr>) Autres prédicats : (oddp <expr>), (evenp <expr>), (subsetp <expr> <expr>)...

67 Fonctions "procédurales"
Liaison variable-expression : (bind <variable> <expression>) Si … alors … sinon : (if <expression> then <action>* [else <action>*]) Boucle tant que : (while <expression> [do] <action>*) Boucle pour : (loop-for-count <range> [do] <action>*) <range> ::= <end-index> | (<variable> [<start> <end>]) Boucle pour chaque : (progn$ (<variable> <expression>) <expression>*) Sélectionner selon : (switch <test> (case <expression> then <action>*)+)

68 Entrées et sorties Opérations sur les fichiers :
(open <file-name> <logical-name> [<mode>]) "r" (lecture seule) "w" (écriture seule) "r+" (lecture et écriture) "a" (ajout) (close [<logical-name>]) (rename <old-file-name> <new-file-name>) (remove <file-name>) (dribble-on <file-name>) (dribble-off) Lecture et écriture dans un flux d’entrée/sortie : (read [<logical-name>]) (readline [<logical-name>]) (printout <logical-name> <expression>*) (format <logical-name> <string> <expression>*)

69 Définir des nouvelles fonctions
Syntaxe qui ne déroute pas les Lispiens : Comme en Lisp, la récursivité est la meilleure méthode pour manipuler et transformer les listes Par convention, les fonctions dont le nom se termine par $ prennent une liste en argument Le constructeur deffunction permet d’écrire des nouvelles commandes CLIPS utilisables dans les RHS des règles Version LISP Version CLIPS (defun coupe (liste index) (if (eq index 0) liste (coupe (cdr liste) (- index 1)))) LISP> (coupe (list ) 2) (3 4) (deffunction coupe$ (?liste ?index) (if (eq ?index 0) then ?liste else (coupe$ (rest$ ?liste) (- ?index 1)))) CLIPS> (coupe$ (create$ ) 2) (3 4)

70 Synthèse des constructeurs
Permettent de déclarer des connaissances (un fichier CLP est constitué de constructeurs) : deftemplate : déclaration d’un template deffacts : déclaration d’un ensemble de faits initiaux defrule : déclaration d’une règle defglobal : déclaration d’une variable globale deffunction : déclaration d’une fonction ou d’une commande defmodule : déclaration d’un module Concernent la couche COOL : defclass : déclaration d’une classe par héritage defmessage-handler : déclaration d’une méthode d’instance definstance : déclaration d’une instance defmethod : déclaration d’une fonction générique

71 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

72 Écriture des conditions (1)
Condition de type filtre : Les symboles ? et $? sont les jokers monovalué et multivalué Les variables multivaluées sont forcément liées avec des listes Possibilité d’écrire des contraintes complexes Condition booléenne : La syntaxe des appels fonctionnels est de type Lisp : <pattern-CE> ::= (<constraint> ... <constraint>) | (<deftemplate-name> (<slot-name> <constraint>)*) <constraint> ::= <constant> | ? | $? | ?<var-symbol> | $?<var-symbol> <test-CE> ::= (test <function-call>) (defrule operator-condition (data ?oper ?x) (value ?oper ?y) (test (> (abs (- ?y ?x)) 3)) => (assert (valid ?oper TRUE)))

73 Écriture des conditions (2)
Opérateurs booléens : Attention à l’utilisation du NOT ! Le AND n’est utile qu’en combinaison avec le OR : <not-CE> ::= (not <conditional-element>) <or-CE> ::= (or <conditional-element>+) <and-CE> ::= (and <conditional-element>+) (defrule high-flow-rate (temp high) (valve open) (not (error-status confirmed)) => (assert (warning "High Temp - Recommend closing of valve"))) (defrule system-flow (error-status confirmed) (or (and (temp high) (valve closed)) (and (temp low) (valve open))) => (assert (alert (level 3) (text "Flow problem"))))

74 Écriture des conditions (3)
Condition existentielle : Permet de tester si un ensemble de filtres est satisfait par au moins un ensemble de faits (ne génère aucune combinatoire) : <exists-CE> ::= (exists <conditional-element>+) (deffacts faits-initiaux (nous sommes en danger) (super-hero "Super Man" occupe) (super-hero "Spider Man" disponible) (super-hero "Wonder Woman" disponible) (super-hero "Flash Gordon" occupe)) (defrule dont-worry ?p <- (nous sommes en danger) (exists (super-hero ? disponible)) => (retract ?p))

75 Écriture des conditions (4)
Condition universelle : Permet de tester si un ensemble de filtres est satisfait pour chaque occurrence d’un autre filtre : <forall-CE> ::= (forall <conditional-element> <conditional-element>+) (defrule all-students-passed ?but <- (bilan ?classe) (forall (eleve ?nom ?classe) (lecture-OK ?nom) (ecriture-OK ?nom) (math-OK ?nom)) => (retract ?but) (assert (bilan ?classe all-students-passed)))

76 Contraintes complexes
Pratique et concis mais source d’erreurs ! Contraintes avec des négations : (personne (age ~30)) (personne (age ?x&~20)) (personne (age ?x&~20&~30)) Contraintes avec des appels fonctionnels : (personne (age ?x&~:(oddp ?x))) (personne (age ?x&:(> ?x 30)&:(< ?x 40))) Que vérifie la règle suivante ? (defrule regle-bidon (personne (nom ?x) (age ?y)) (personne (nom ~?x) (age ?w&?y|=(* 2 ?y))) => (assert (vraiment bidon la regle)))

77 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

78 Le moteur de CLIPS Compilation de la base de règles :
Les règles sont compilées « en dur » sous la forme d’un réseau Le système ne regarde que ce qui change pour les règles concernées quand de nouveaux faits sont ajoutés ou modifiés La base de faits est intimement liée à la base de règles Les faits sont triés et propagés très rapidement Réseau RETE et algorithme de propagation : Implémentés pour la première fois dans les années 90 (OPS 5) Les règles sont compilées sous la forme de deux réseaux : Arbre de discrimination : filtrer et propager les nouveaux faits Chaque feuille contient une prémisse et chaque nœud un test Réseau de jointures : vérifier les correspondances entre variables Chaque nœud regroupe 2 à 2 les prémisses d’une même règle

79 Exemple de compilation
Soit les deux règles suivantes : (defrule make-goal-near (goal monkey on ?x) (near ?x ?y) => (assert (goal monkey near ?y))) (defrule make-goal-emptyhanded (monkey near ?y) (assert (goal emptyhanded monkey)))

80 Arbre de discrimination
Propage et filtre chaque nouveau fait : Le nœud de distribution duplique et envoie des tokens +fait Les tokens sont propagés (ou non) dans les branches de l’arbre : nœud de distribution taille = 3 taille = 4 monkey near goal near monkey (monkey near ?y) (near ?x ?y) on (goal monkey on ?x)

81 (assert (goal monkey near ?y))) (assert (goal emptyhanded monkey)))
Réseau de jointures Vérifie les correspondances entre les variables : Les nœuds regroupent 2 à 2 les prémisses d’une même règle Les substitutions sont propagées (ou non) aux nœuds suivants : (goal monkey on ?x) (near ?x ?y) (monkey near ?y) (goal monkey on ?x) (near ?x ?y) ?x ?x ?y (assert (goal monkey near ?y))) (assert (goal emptyhanded monkey)))

82 Première optimisation
Factoriser les feuilles de l’arbre de discrimination : (goal monkey on ?x) (near ?x ?y) (monkey near ?y) ?x ?x ?y (assert (goal monkey near ?y))) (assert (goal emptyhanded monkey)))

83 (assert (goal monkey near ?y))) (assert (goal emptyhanded monkey)))
Seconde optimisation Factoriser les nœuds du réseau de jointures : (goal monkey on ?x) (near ?x ?y) (monkey near ?y) ?x ?y (assert (goal monkey near ?y))) (assert (goal emptyhanded monkey)))

84 Arbre de discrimination
Réseau optimisé nœud de distribution L = 3 L = 4 Arbre de discrimination monkey near goal near monkey (monkey near ?y) (near ?x ?y) on ?y ?x (goal monkey on ?x) Réseau de jointures (assert (goal monkey near ?y)) (assert (goal emptyhanded monkey))

85 Efficacité de RETE L’efficacité d’un réseau RETE ne dépend pas tellement du nombre de règles et de faits, mais du nombre de correspondances partielles générées et stockées : (defrule mauvaise-regle (item ?x) (item ?y) (item ?z) (item ?w) (liste ?x ?y ?z ?w) => (defrule bonne-regle Cette règle doit générer toutes les permutations possibles des faits « item » avant de trouver une permutation qui corresponde au fait « liste » S’il y a n faits, il y aura n ! / (n-p) ! configurations à mémoriser (avec 10 faits, cela fait 10 x 9 x 8 x 7 = 5040 configurations différentes). Pour une exécution efficace, il est essentiel de placer les conditions les plus contraignantes (celles qui ont le moins de chance d’être vérifiées) avant les autres.

86 Stratégies de résolution
Stratégies de résolution de conflits : Stratégies Depth et Breadth : Insertion au début de l’agenda des tâches (profondeur d’abord) Insertion à la fin de l’agenda des tâches (largeur d’abord) Stratégie Random : Les règles de même intérêt sont insérées dans l’agenda de façon aléatoire Stratégies Simplicity et Complexity : Insertion en fonction de la spécificité croissante (simplicité d’abord) Insertion en fonction de la spécificité décroissante (complexité d’abord) Exemple : la spécificité de la règle ci-dessous est de 5 : Stratégies Lex et Mea : Voir pages suivantes (defrule exemple (item ?x ?y ?x) (test (and (numberp ?x) (> ?x (+ 10 ?y)) (< ?x 20)))

87 Stratégies Lex et Mea Stratégie Lex : Stratégie Mea : Exemple :
Favorise les règles qui utilisent les déductions les plus récentes Favorise les règles qui utilisent le plus de conditions Les négations sont moins prioritaires que les autres conditions Stratégie Mea : La première prémisse de chaque règle est prioritaire La stratégie Lex est utilisée pour résoudre les conflits restants Exemple : (deffacts faits-initiaux (f-1) (f-2) (f-3) (f-4)) (defrule R1 (f-1) (f-2) (f-3) => ... ) (defrule R2 (f-3) (f-1) => ... ) (defrule R3 (f-2) (f-1) => ... ) (defrule R4 (f-1) (f-2) (not (f-5)) => ... ) (defrule R5 (f-1) (f-2) (f-3) (not (f-5)) => ... ) (defrule R6 (f-1) (f-4) => ... )

88 Stratégies Lex et Mea R6 R5 R1 R2 R4 R3 4 3 3 3 2 2 1 2 2 1 1 1 1 1 n
Agenda trié en fonction de la stratégie Lex : Agenda trié en fonction de la stratégie Mea : 1 1 n n R6 R5 R1 R2 R4 R3 2 2 n n R2 R3 R6 R5 R1 R4 Première prémisse Lex

89 Plan du cours Présentation de CLIPS (historique, caractéristiques)
Survol de CLIPS (faits, règles, filtrage, agenda) Le monde des cubes (trace, débuggage, négation) Justification et utilisation des structures (templates) Manipulation des listes et fonctions sur les listes Aspects fonctionnels (fonctions, prédicats, E/S) Synthèse sur les conditions et contraintes complexes Le moteur CLIPS (réseau RETE, résolution de conflits) Aperçu de la couche COOL (classes et méthodes)

90 La couche COOL CLIPS Object Oriented Language :
Abstraction + héritage + encapsulation + polymorphisme Sortes de templates hiérarchisés avec héritage multiple La classe générique est OBJECT mais on utilise plutôt USER Une classe est réactive lorsque ses instances peuvent être filtrées (defclass <classe> (is-a <super-classe>*) (role abstract|concrete) [(pattern-match reactive)] (slot|multislot <attribut> [(type <type>)] ... )*) CLIPS> (defclass DUCK (is-a USER) (role concrete)) CLIPS> (make-instance of DUCK) [gen1] CLIPS> (make-instance Gaetan of DUCK) [Gaetan]

91 Hiérarchie des classes
OBJECT USER PRIMITIVE INITIAL-OBJECT NUMBER INSTANCE ADDRESSE MULTIFIELD LEXEME INTEGER FLOAT SYMBOL STRING INSTANCE-ADDRESS EXTERNAL-ADDRESS INSTANCE-NAME FACT-ADDRESS

92 La classe des canards À tester
(defclass DUCK (is-a USER) (role concrete) (slot son (create-accessor read-write)) (slot age (create-accessor read-write) (default 0))) (defmessage-handler DUCK parler (?phrase) (printout t ?phrase crlf)) (defmessage-handler DUCK parler before (?phrase) (printout t ?self:son " ")) (definstances objets-initiaux (Donald of DUCK)) CLIPS> (reset) CLIPS> (send [Donald] put-son coin-coin) CLIPS> (send [Donald] print) CLIPS> (make-instance Gaetan of DUCK (son coui-coui) (age 2)) CLIPS> (send [Gaetan] get-age) CLIPS> (instances) CLIPS> (send [Donald] parler "Hello World") À tester

93 Filtrage des objets (defclass DUCK (is-a USER) (role concrete)
(pattern-match reactive) (slot son (create-accessor read-write)) (slot age (create-accessor read-write) (default 0))) (definstances OBJETS-INITIAUX (Donald of DUCK (son coin-coin) (age 2)) (Gaetan of DUCK (son coui-coui) (age 4)) (Gedeon of DUCK (son piou-piou) (age 5)) (Daisy of DUCK (son pouet-pouet))) (defmessage-handler DUCK crier () (printout t ?self ?self:son crlf))) (defrule klaxon ?canard <- (object (is-a DUCK) (age ~0)) => (send ?canard crier))

94 That’s all Folks !