Vous êtes sur la page 1sur 6

Formations en Informatique de Lille – 2005/2006

Syst`emes d’Inf´erences

septembre 2005

– 2005/2006 Syst`emes d’Inf´erences septembre 2005 Syst`emes experts JESS 1 Introduction Jess est un programme

Syst`emes experts JESS

1 Introduction

Jess est un programme permettant la manipulation de syst`emes experts d’ordre 1. Il est ´ecrit en java, et poss`ede de nombreuses connexions avec ce langage (utilisation d’objets java dans les r`egles dans un sens, utilisation de syst`emes experts dans des programmes java dans l’autre sens). Il utilise l’algorithme Rete.

2 Le logiciel

Le programme, sous forme de fichier jar ex´ecutable, peut se charger sur http://herzberg.ca. sandia.gov/jess/ La documentation en ligne se trouve a` l’adresse http://herzberg.ca.sandia.gov/jess/docs/ 70/, ou encore sur http://herzberg.ca.sandia.gov/jess/manual.pdf D´ecompressez le fichier, puis lancez le programme avec : java -classpath jess.jar jess.Main ou java -classpath jess.jar jess.Main nom de fichier.clp

3 Les commandes

La syntaxe des commandes a` l’int´erieur de Jess suit la syntaxe des langages fonctionnels (scheme, vous vous rappelez ?) : toutes les commandes sont des fonctions entre parenth`eses. Quelques commandes de base :

– (batch ”nom de fichier”) : charge une base. Les fichiers se terminent g´en´eralement par le suffixe clp, d’apr`es CLIP, le pr´edecesseur de Jess

– (exit) : pour sortir du programme.

– (reset) : pour pr´eparer les d´eductions (lecture des faits, fixer un fait initial qui permettra de lancer la machine, rep´erage des r`egles d´eclenchables, oubli des faits appris).

– (run) : pour lancer la d´eduction.

– (facts) : pour voir la liste des faits (et leur num´ero)

– (watch all) : pour obtenir un maximum de verbosit´e lors des d´eductions (faits d´eduits, r`egles

.Les versions (watch rules), (watch compilations), (watch acti-

applicables, r`egles appliqu´ees

vations) et (watch facts) sont un peu moins loquaces.

4 Ecrire des bases

4.1

Basiques

4.1.1 Composants de base

atomes sont des noms d’identificateurs

nombres syntaxe standard (entiers, double

.)

2

Formations en Informatique de Lille – 2005/2006 : Syst`emes d’Inf´erences

chaˆınes syntaxe standard

commentaires : pr´ec´ed´es d’un point virgule, courent jusqu’`a la fin de la ligne.

4.1.2 Fonctions

Une fonction est une liste, dont le premier ´el´ement est le nom de la fonction, les arguments suivants en sont les param`etres : (+ x 3) : Jess ´evalue et retourne la valeur calcul´ee. Notez la syntaxe un peu bizarre de l’impression : printout t ‘‘texte ‘‘ 42 ‘‘ texte’’ crlf, le t au d´epart et le crlf a` la fin ´etant n´ecessaire. Cette commande imprime un message sur l’´ecran.

4.1.3 Variables

Pour utiliser une variable dans une fonction, il faut utiliser un identificateur pr´ec´ed´e d’un point d’interrogation. Pour donner une valeur a` une variable, on utilise la fonction bind :

Jess>

(bind

?x

123)

123

Jess>?x

 

123

4.1.4

D´efinir des fonctions

la syntaxe de la d´efinition de fonctions est la suivante

(deffunction

<expr>*

<function-name>

[<return-specifier>])

Comme par exemple, dans :

[<doc-comment>]

Jess>

(deffunction

max

(?a

?b)

(if

(>

?a

?b)

then

(return

else

(return

?a)

?b)))

(<parameter>*)

On peut ensuite l’appeler partout dans le programme : (max 3 5)

4.2 La base de connaissances

4.2.1 Les faits simples

Les faits sont des listes caract´eris´ees par leur premier ´el´ement :

(habile

singe)

(proche

singe

sol)

(poids

chaise

25)

On utilise la fonction assert pour ajouter un ou des faits a` la base :

(assert

(sur

singe

sol)

(proche

banane

chaise))

Sym´etriquement, la fonction retract permet d’enlever un fait de la base :

retract

(fact-id

1))

Retire de la base le fait num´ero 1 (on peut connaˆıtre le num´ero d’un fait que l’on veut retirer de la base)

Syst`emes experts JESS

3

4.2.2 Les faits structur´es

On peut d´efinir des faits contenant plusieurs champs. Il faut alors pr´ealablement d´efinir la structure dans un template :

deftemplate

<deftemplate-name>

[extends

<classname>]

[<doc-comment>]

[(slot

<slot-name>

[(default

|

default-dynamic

<value>)]

 

[(type

<typespec>))]*)

Comme dans :

(deftemplate

automobile

"A

(slot

(slot

(slot

(slot

specific

make)

model)

year

color

car."

(type

INTEGER))

(default

white)))

Jess recommande de ne pas utiliser la d´efinition de type. Les slots sont les noms des diff´erents champs. On peut ajouter des faits structur´es a` la base avec assert :

(assert

(automobile

(make

(year

1997)))

Chrysler)

(model

LeBaron)

Cette voiture est blanche par d´efaut. On peut modifier la valeur d’un champ d’un fait structur´e existant avec la fonction modify :

Jess>

(assert

(automobile

(make

Chrysler)

(model

LeBaron)

(year

1997)))

 

<Fact-0>

 

Jess>

(modify

(fact-id

0)

(make

Ford))

(Possible parce que l’on sait que le fait a le num´ero 0 : voir plus loin le cas g´en´eral)

4.2.3 D´efinir tous les faits initiaux

Il serait laborieux de construire les faits a` partir de la fonction assert. La fonction deffacts permet de d´efinir tous les faits initiaux en une fois :

(deffacts

my-facts

"La

base

de

faits"

(habile

singe)

 

(sur

singe

sol)

(inerte

chaise)

 

(proximite

(un

banane)

(deux

sol)

(verite

FALSE))

)

Ces faits seront introduits dans la base a` chaque commande reset.

4

Formations en Informatique de Lille – 2005/2006 : Syst`emes d’Inf´erences

4.2.4 Les r`egles

Une r`egle est d´efinie par la fonction defrule, qui ob´eit a` la syntaxe suivante :

(defrule

nom

‘‘commentaire’’

premisse1

premisse2

premisseN

=>

action1

action2

actionP

La r`egle se d´eclenchera si chaque pr´emisse peut ˆetre unifi´ee avec un fait, ou si une condition est v´erifi´ee, par exemple :

(defrule

r3

(deplacer

?X

?Y

?Z)

(proximite

(un

?Z)

(deux

sol)

(verite

FALSE))

=>

(assert

(sous

?Y

?Z))

)

se d´eclenchera si X peut d´eplacer Y vers Z, et si Z n’est pas proche du sol. dans ce cas, on en d´eduira que Y est sous Z (fait rajout´e a` la base). Notez l’utilisation de variables (commen¸cant par des points d’interrogation), qui permet de relier entre elles les deux pr´emisses par une condition. Un autre exemple :

(defrule

r4

(explore

?x

?y

FALSE)

 

(test

(courant_d_air

?x

?y))

=>

(printout

t

"Un

courant

d’air

en

"

?x

"

"?y

crlf)

(assert

(explore

?x

?y

TRUE)

(vent

?x

?y))

)

Ici, la r`egle se d´eclenchera si la premi`ere pr´emisse peut s’unifier avec un fait connu, par contre, la deuxi`eme condition est un test, qui permettra d’activer la r`egle si la fonction courant d air

retourne le bool´een TRUE. Avant d’ˆetre utilis´ees dans la fonction test, les variables ?x et ?y doivent avoir ´et´e unifi´ees avec des faits, il est donc important que les deux “pr´emisses” soient d´efinies dans cet ordre ! On peut fixer des conditions sur les variables apparaissant en partie gauche d’une r`egle (on en a d´ej`a vue une : un mˆeme nom de variable repr´esente le mˆeme objet) :

– La diff´erence : (sous ?Y ?Z&~?X) : la pr´emisse sera v´erifi´ee quand ?Z sera diff´erent de ?X

– Le r´esultat (bool´een) d’un appel de fonction : (sous ?Y ?Z&:(> ?Z 10)) se d´eclenchera si ?Z est sup´erieur a` 10 (`a condition que le deuxi`eme argument de sous soit un nombre !) Voici un exemple plus ou moins explicite regroupant plusieurs possibilit´es :

Jess>

(defrule

example-3

(not-b-and-c

(different

(same

(more-than-one-hundred

?n1&~b

?n2&~c)

?d1

?d2&~?d1)

?s

?s)

?m&:(>

?m

100))

(red-or-blue

red|blue)

 

=>

(printout

t

"Found

what

I

wanted!"

crlf))

Syst`emes experts JESS

5

On peut utiliser les connecteurs logiques pour combiner les pr´emisses :

Jess>

(defrule

or-example-1

(or

(a)

(b)

(c))

=>)

Jess>(defrule

or-example-2a

Jess>

(and

(or

(a)

 

(b))

 

(c))

=>)

(defrule

example-7

(person

?x)

 

(not

(married

?x))

 

=>

(printout

t

?x

"

is

not

married!"

crlf))

La deuxi`eme d´efinition de r`egle a peu d’int´erˆet (on suppose par d´efaut que l’on fait la conjonction des pr´emisses), mais permet des combinaisons quelconques d’op´erateurs bool´eens. Remarquez dans la troisi`eme r`egle que la variable ?x a besoin d’ˆetre d’abord substitu´ee dans person avant de pouvoir ˆetre utilis´ee dans not. test, d´ej`a rencontr´e, permet de prendre des d´ecisions en fonction de la valeur d’une fonction :

Jess>

(defrule

rule_1

(foo

?X)

(test

(>

?X

3))

=>)

D´eclenchera la r`egle si ?X v´erifie foo et si ?X est plus grand que 3.

5 Utiliser Jess

Pour un probl`eme donn´e, il vous faudra :

– Coder le probl`eme.

– D´efinir les fonctions auxiliaires, les structures ´eventuelles de faits.

– D´efinir les faits initiaux.

– D´efinir les r`egles. Ensuite, vous pouvez tester votre syst`eme dans Jess :

– lancer Jess

– Charger votre fichier : (batch "fichier")

– Demander qu’il vous affiche ce qu’il fait : (watch all)

– Pr´eparer le syst`eme : (reset)

– Lancer : (run)

Question 5.1 :

Ecrivez un ensemble de r`egles inspir´e du monde du Wumpus : on se place dans

un monde sans danger (un damier 4x4). Le chasseur est en (1,1), il doit parcourir toutes les cases

.)

(version 2 : ne pas repasser par la mˆeme case

Question 5.2 : Le monde devient un peu plus hostile : il y a un puits (`a une position que vous fixez, mais le chasseur ne la connaˆıt pas) : une fonction courantdair lui permet de savoir si une case donn´ee est parcourue ou non par un courant d’air. Ecrivez un ensemble de r`egles qui permet

6

Formations en Informatique de Lille – 2005/2006 : Syst`emes d’Inf´erences

au chasseur de se d´eplacer sur les cases sans danger.

Question 5.3 : Compl´etez l’ensemble de r`egles pr´ec´edent pour que le chasseur puisse, au moins approximativement, deviner la position des puits.

Plus dur

Question 5.4 : On change d’animal : codez le probl`eme du singe et des bananes !

1.

Si on est habile et proche d’un objet, alors on peut l’atteindre.

2.

Si on est sur un objet P 1 , qui lui-mˆeme se trouve sous un objet P 2 , alors on est proche de P 2

3.

D´eplacer un objet vers un objet qui est loin du sol, c’est le placer dessous.

4.

Si X peut bouger, et qu’il est proche d’un objet, alors il peut monter dessus.

5.

Si X est anim´e et est proche d’un objet P 1 , pos´e sur le sol, alors X peut d´eplacer P 1 vers n’importe quel objet P 2

6.

SI X est anim´e, il peut aller vers tout objet pos´e sur le sol.

7.

Si on se dirige vers un objet, alors on devient proche de lui (et ´eloign´e de tout objet dont on

´etait proche

.)

8.

Si X est anim´e, et juch´e sur un objet P , il peut en descendre (et devient alors proche de P )

9.

Le singe est sur le sol.

10.

Les bananes sont accroch´ees au plafond.

11.

il y a une chaise (pos´ee sur le sol).

12.

Lorsque le singe est sur la chaise, il peut attraper les bananes.

Fig. 1 – Le probl`eme du singe

Question 5.5 : Comment pourrait-on programmer le Tic-Tac-Toe ?