systèmes experts avec jess

1. ECOLE NATIONALE D’INGENIEURS DE TUNIS
Compte redu système
expert
Application à JESS
Dghaies Marwa
3ème Info 2

2. TP 1 Présentation de Jess
Exercice d’application
Suppose you wanted to write an expert system to determine how a mobile robot should
respond to a traffic light. The rules for the red and green light situations can be written as
follows.
(defrule red-light
(light red)
=>
(printout t "STOP" crlf)
)
(defrule green-light
(light green)
=>
(printout t "GO" crlf)
)
1. For all questions Write a command and describe what you see?
After the rules have been entered into Jess, assert a fact (light red) and run.
Jess>defrule red-light
(light red)
=>
(printout t "STOP" crlf)
)
Jess>(defrule green-light
(light green)
=>
(printout t "GO" crlf)
)
Jess>(assert (light red))
Jess>(run)
2. Watch fact
Jess> (watch facts)
TRUE
Jess> (reset)
==> f-0 (MAIN::initial-fact)
TRUE
Jess> (unwatch facts)
TRUE
3. Retract fact (light red) and run
Jess> (retract 1)
Jess> (facts)
2

3. 4. Assert fact (light green) and run.
Jess>(assert (light green))
Jess> (facts)
Jess>(run)
3

4. 5. Create a Button in the Jess Language who “run” these rules.
Jess> (import java.awt.*)
Jess> (import java.awt.event.*)
Jess> ;; Create the widgets
(defglobal ?*f* = (new Frame "Button Demo"))
Jess> (defglobal ?*b* = (new Button "Hello"))
Jess> ;; Add a listener to the button
(?*b* addActionListener (implement ActionListener using (lambda (?name ?evt)
(run))))
Jess> ;; Assemble and display the GUI
(?*f* add ?*b*)
Jess> (?*f* pack)
Jess> (set ?*f* visible TRUE)
Jess> ;; Add a WINDOW_CLOSING listener
(import java.awt.event.WindowEvent)
(?*f* addWindowListener (implement WindowListener using (lambda (?name ?event)
(if (= (?event getID) (WindowEvent.WINDOW_CLOSING)) then
(exit)))))
4

5. TP 2 : Arbre généalogique
1) Comment faut-il modifier la première prémisse de chacune des 4 règles de calcul
d’ancêtre pour sélectionner l’individu à étudier ? Faites une exécution.
(deftemplate individu
(slot nom)
(slot pere)
(slot mere)
(slot a_etudier (default non))
)
((defrule startup
?f<-(initial-fact)
=>
(printout t "Indiquez l'individu dont vous recherchez un ancêtre (ou
tapez fin pour arrêter) : ")
(bind ?x (sym-cat (readline)))
(assert (a_etudier ?x))
(retract ?f)
)
(defrule a_etudier
(a_etudier ?x)
?f<-(individu (nom ?x)(a_etudier non))
=>
(modify ?f (a_etudier oui))
)
(defrule ancetresinconnus
(a_etudier ?x)
(individu (nom ?x)(pere nil)(mere nil))
=>
(printout t ?x " n'a pas d'ancêtres connus" crlf)
)
(defrule imprime
(declare (salience -10))
(a_etudier ?y)
(ancetre ?x ?y)
=>
(printout t ?x " est un ancetre de " ?y crlf)
5

6. )
2) Ecrire une règle qui permette de redemander un nom à l’utilisateur si jamais celui-ci a
indiqué un nom ne figurant pas dans la famille. Quelle priorité faut-il donner à cette règle
?
(defrule control_choix
(declare (salience 500))
(a_etudier ?x)
(not ( individu (nom ?x)))
=>
(printout t "Vous devez choisir un nom qui existe!" crlf)
)
3) Ecrire une règle permettant de stopper le moteur d’inférences si l’utilisateur indique «
fin » comme nom d’utilisateur. Quelle priorité faut-il donner à cette règle ?
(defrule control_fin
(declare (salience 700))
6

7. (a_etudier fin)
=>
(exit))
4) Ecrire une règle qui permette de demander un nouvel individu à l’utilisateur après que
le système ait affiché tous les ancêtres de l’individu précédent. Quelle priorité faut-il
donner à cette règle ?
(defrule selctionner
(declare (salience -20))
=>
(printout t "Indiquez l'individu dont vous recherchez un ancêtre (ou
tapez fin pour arrêter) : ")
(bind ?x (sym-cat (readline)))
(assert (a_etudier ?x))
(run_boucle)
)
(deffunction run_boucle()
(reset)
(run)
)
Exercice pratique :
(deftemplate droite
(slot a)
(slot b)
(slot c)
)
(deftemplate point
(slot x)
(slot y)
)
(defrule startup
=>
(printout t "entrez les coordonnées de votre droite : ")
7

8. (bind ?x1 (sym-cat (readline)))
(bind ?y1 (sym-cat (readline)))
(bind ?z1 (sym-cat (readline)))
(assert (droite (a ?x1) (b ?y1) (c ?z1)))
(printout t "entrez les coordonnées du point : ")
(bind ?x2 (sym-cat (readline)))
(bind ?y2(sym-cat (readline)))
(assert (point (x ?x2) (y ?y2)))
)
(defrule calcul_distance
(droite (a ?x1 )(b ?y1) (c ?z1))
(point (x ?x2) (y ?y2))
=>
(calcul a b c x y)
)
(deffunction calcul (?a ?b ?c ?x ?y)
(bind ?result (/ (+ (+ (* ?a ?x) (* ?b ?y)) c) (+ (* ?a ?a) (* ?b ?b))))
(return ?result)
)
(reset)
(run)
8

9. TP 3
Dans ce TP nous allons utiliser la programmation en jess pour crée dans une première
application un jeu très connu qui celui du « tictac » et dans une seconde application nous allons
traiter des calculs mathématiques que nous avons pris l’habitude de traiter couramment en java
ou encore en C++.
1) Vous essayez d’exécuter le fichier « tictac.clp » avec l’instruction (batch nomfichier)
Jess> (batch tictac.clp)
2) Le programme ne s’arrête pas dans le cas où il n’y a pas de gagnant et toutes les cases
sont remplies. Améliorer le code en ajoutant une règle à priorité réduite traitant ce cas.
(defrule check-notwin-backslash
(declare (salience 10))
(case 1 1 ?a)
(case 1 2 ?b)
(case 2 2 ?a)
(case 3 2 ?a)
(case 2 1 ?b)
(case 1 3 ?a)
(case 3 1 ?b)
(case 2 3 ?b)
(case 3 3 ?b)
(test (neq ?a _))
(test (neq ?b _))
9

10. =>
(printout t "Aucun gagneur " crlf "Fin de la partie..." crlf)
(halt)
)
3) Ajouter une règle permettant de demander si le joueur veut rejouer ou non.
(deffunction run_n_time(?rep)
(while (test (neq ?rep n)) do
((reset)
(run)
(printout t "Voulez vous rejouez?")
(bind ?rep (read))
)
)
)
10

11. TP 4
; soduko.clp
; Fait par Sébastien Gagné
; Pour le cours de LOG625
;
; Utilisation : charger le fichier dans Jess
; Pour jouer son coup, il faut entrer la ligne et la colone avec un espace entre les
deux.
;
; 2008-05-28 : Version initiale
(clear)
; === Faits de base ===
; Les cases
(deffacts cases
(case 1 1 _)
(case 1 2 _)
(case 1 3 _)
(case 2 1 _)
(case 2 2 _)
(case 2 3 _)
(case 3 1 _)
(case 3 2 _)
(case 3 3 _))
; Pour chager de case facilement
(deffacts prochain-joueur
(next X X)
)
;=== Règles ===
;Init rule
;Le read ici est pour que les readline suivants fonctionnent
(defrule startup
(declare (salience 60))
=>
(printout t "Voulez vous jouer (O/N) ? " crlf)
(bind ?x (read))
(if(= ?x n) then (halt)
else(while (eq ?x o) do
(assert (tour X))
(assert (show-grid))
(run)
(printout t "Voulez vous jouer (O/N) ? " crlf)
(bind ?x (read))
(reset)
)
(halt)
)
)
; Demander le coup du joueur
(defrule do-move
11

12. (declare (salience 60))
(tour ?a)
(not (action ? ? ?))
=>
(printout t "Ou voulez-vous mettre votre chiffre ? (ligne colone chiffre)"
crlf)
(assert (action (explode$ (readline))))
)
; "Effectuer" le tour et changer de joueur
(defrule go-next-player
?t <- (tour ?curPlayer)
(next ?curPlayer ?next)
?a <- (action ?l ?c ?y)
?case <- (case ?l ?c ?)
=>
(retract ?t)
(retract ?a)
(retract ?case)
(assert (case ?l ?c ?y))
(assert (tour ?next))
(assert (show-grid))
)
; Afficher la grille actuelle du jeu
(defrule show-grid-to-player
(declare (salience 100))
?fact <- (show-grid)
(case 1 1 ?a)
(case 1 2 ?b)
(case 1 3 ?c)
(case 2 1 ?d)
(case 2 2 ?e)
(case 2 3 ?f)
(case 3 1 ?g)
(case 3 2 ?h)
(case 3 3 ?i)
=>
(printout t crlf ?a " " ?b " " ?c crlf)
(printout t ?d " " ?e " " ?f crlf)
(printout t ?g " " ?h " " ?i crlf crlf)
(retract ?fact)
)
;; Vérifier si on a un gagnant
(defrule check-win-cas1
(declare (salience 50))
(case 1 1 1)
(case 1 2 3)
(case 1 3 2)
(case 2 1 3)
(case 2 2 2)
(case 2 3 1)
(case 3 1 2)
(case 3 2 1)
(case 3 3 3)
;(test (neq ?a _))
=>
(printout t "Bravo, tu as gagné !" crlf "Fin de la partie..." crlf)
(halt)
)
12

13. (defrule check-win-cas2
(declare (salience 50))
(case 1 1 2)
(case 1 2 1)
(case 1 3 3)
(case 2 1 1)
(case 2 2 3)
(case 2 3 2)
(case 3 1 3)
(case 3 2 2)
(case 3 3 1)
;(test (neq ?a _))
=>
(printout t "Bravo, tu as gagné !" crlf "Fin de la partie..." crlf)
(halt)
)
(defrule check-win-cas3
(declare (salience 50))
(case 1 1 2)
(case 1 2 3)
(case 1 3 1)
(case 2 1 3)
(case 2 2 1)
(case 2 3 2)
(case 3 1 1)
(case 3 2 2)
(case 3 3 3)
=>
(printout t "Bravo, tu as gagné !" crlf "Fin de la partie..." crlf)
(halt)
)
(defrule check-win-cas4
(declare (salience 50))
(case 1 1 3)
(case 1 2 2)
(case 1 3 1)
(case 2 1 2)
(case 2 2 1)
(case 2 3 3)
(case 3 1 1)
(case 3 2 3)
(case 3 3 2)
=>
(printout t "Bravo, tu as gagné !" crlf "Fin de la partie..." crlf)
(halt)
)
(defrule check-win-cas5
(declare (salience 50))
(case 1 1 3)
(case 1 2 1)
(case 1 3 2)
(case 2 1 1)
(case 2 2 2)
(case 2 3 3)
(case 3 1 2)
(case 3 2 3)
13

14. (case 3 3 1)
=>
(printout t "Bravo, tu as gagné !" crlf "Fin de la partie..." crlf)
(halt)
)
(defrule check-win-cas6
(declare (salience 50))
(case 1 1 1)
(case 1 2 2)
(case 1 3 3)
(case 2 1 2)
(case 2 2 3)
(case 2 3 1)
(case 3 1 3)
(case 3 2 1)
(case 3 3 2)
=>
(printout t "Bravo, tu as gagné !" crlf "Fin de la partie..." crlf)
(halt)
)
(defrule check-loose-cas1
(declare (salience 600))
?a <- (action ?l ?c ?n)
(case ?l ? ?n)
?b <- (tour ?x)
=>
(printout t "Too Baaaad" crlf)
(retract ?a)
(retract ?b)
(assert (tour ?x))
)
(defrule check-loose-cas2
(declare (salience 600))
?a <- (action ?l ?c ?n)
(case ? ?c ?n)
?b <- (tour ?x)
=>
(printout t "Too Baaaad" crlf)
(retract ?a)
(retract ?b)
(assert (tour ?x))
)
; Il faut valider qu'on choisi une case vide
(defrule valider-case-vide
(declare (salience 500))
?a <- (action ?l ?c ?n)
(case ?l ?c ?x)
(test (neq ?x _))
?b <- (tour ?t)
=>
(printout t "Vous devez choisir une case vide !!!" crlf)
14

15. (retract ?a)
(retract ?b)
(assert (tour ?t))
(assert (show-grid))
)
; Validation pour les faits "action" mal formées
(defrule valider-action-invalide0
(declare (salience 500))
?a <- (action)
?b <- (tour ?x)
=>
(printout t "Action invalide, vous devez entrer la ligne et la colonne et le
chiffre séparée d'un espace" crlf)
(retract ?a)
(retract ?b)
(assert (tour ?x))
)
(defrule valider-action-invalide1
(declare (salience 500))
?a <- (action ?)
?b <- (tour ?x)
=>
(printout t "Action invalide, vous devez entrer la ligne et la colonne et le
chiffre séparée d'un espace" crlf)
(retract ?a)
(retract ?b)
(assert (tour ?x))
)
(defrule valider-action-invalide2
(declare (salience 500))
?a <- (action ? ?)
?b <- (tour ?x)
=>
(printout t "Action invalide, vous devez entrer la ligne et la colonne et le
chiffre séparée d'un espace" crlf)
(retract ?a)
(retract ?b)
(assert (tour ?x))
)
(defrule valider-action-invalide4
(declare (salience 500))
?a <- (action ? ? ? ?)
?b <- (tour ?x)
=>
(printout t "Action invalide, vous devez entrer la ligne et la colonne et le
chiffre séparée d'un espace" crlf)
(retract ?a)
(retract ?b)
(assert (tour ?x))
)
(defrule valider-action-invalide5
(declare (salience 500))
?a <- (action ? ? ? ? ?)
?b <- (tour ?x)
=>
(printout t "Action invalide, vous devez entrer la ligne et la colonne et le
chiffre séparée d'un espace" crlf)
(retract ?a)
(retract ?b)
(assert (tour ?x))
15

16. )
; Valider qu'on choisisse une case qui existe
(defrule valide-case-existe
(declare (salience 500))
?a <- (action ?l ?c ?y)
(not (case ?l ?c ?))
?b <- (tour ?x)
=>
(printout t "Vous devez choisir une case qui existe!" crlf)
(retract ?a)
(retract ?b)
(assert (tour ?x))
)
; Démarrer la partie !
(reset)
(run)
16

17. 17