Intelligent Control - Bagger

Rapport de TP

Batoun Mohammed Amine Ecole Mohammadia d’Ingénieurs

RAMI Yousra 2018-2019

INTELLIGENT CONTROL - BAGGER 0

 Table de matières
Introduction 2
Bagger simplifié 3
Sous-système expert suggestions 3
Sous-système expert petits articles 10
Bagger compliqué 14
Sous-système expert suggestions 14
Sous-système expert petits articles 15

INTELLIGENT CONTROL - BAGGER 1

Introduction

Intelligence artificielle :
L'intelligence artificielle (IA, ou AI en anglais pour Artificial Intelligence) consiste à
mettre en œuvre un certain nombre de techniques visant à permettre aux machines
d'imiter une forme d'intelligence ré elle. L'IA se retrouve implé menté e dans un nombre
grandissant de domaines d'application.

Système Expert :
Les systè mes experts sont une des applications de l’IA. Ils imitent le raisonnement d’un
professionnel spé cialiste dans un domaine pré cis par exemple en matiè re de diagnostic
de panne automobile ou de diagnostic mé dical. Le systè me pose des questions à
l’utilisateur, ses ré ponses orientent le systè me qui au fur et à mesure affine son
diagnostic.

Moteur
d'inférence

Base de Base de
règles faits

Un systè me expert se compose de 3 parties formant un cycle d’infé rence :

Travail demandé :
Il faut programmer en langage C (en plus d’un autre langage optionnel) un prototype du
système expert Bagger étudié en 2ème année lors du cours de l’Intelligence Artificielle et
Emotionnelle en respectant les étapes de conception d’un système expert.

Un premier prototype comportera un modèle trivial du système expert, ensuite un

modèle compliqué sera programmé en ajoutant de nouvelles règles à la base de règles.

INTELLIGENT CONTROL - BAGGER 2

Bagger simplifié
Les deux sous-systèmes choisis dans cette étude sont les suivants :

 Petits Articles
 Suggestions

L’espace de travail est limité aux articles suivants : biscuit, thé, lait 0.5 L, sucre,
dentifrice, brosse à dents et shampoing. Le système expert demandera à l’utilisateur
d’introduire les articles achetés pour qu’il puisse les traiter. Le premier sous-système
expert actif est Suggestions.

Il est indiqué que la capacité d’un sac ne peut pas dépasser 4 petits articles.

Sous-système expert Suggestions :

La base de règles associée est la suivante :

 Règle 1 : suggestion lait 0.5 L

 Règle 2 : suggestion brosse à dents
 Règle 3 : passage au système expert petits articles

Algorithme des règles applicables :

 Si (Biscuit existe) & (Lait 0.5 L n’existe pas)

o Alors (Suggestion lait 0.5 L)
o Règle 1 applicable
 Si (Dentifrice existe) & (Brosse à dents n’existe pas)
o Alors (Suggestion brosse à dents)
o Règle 2 applicable
 Sinon
o Passage au sous-système expert petits articles
o Règle 3 applicable

Priorité des règles :

Règle 1 > Règle 2 > Règle 3

Algorithme de la règle élue :

 Si (Règle 1 est active)
o Alors (Suggestion lait 0.5 L)
o Règle 2 inactive
o Règle 3 inactive
INTELLIGENT CONTROL - BAGGER 3
 o (Suggestion lait 0.5 L) ajoutée à la trace de raisonnement
o (Biscuit existe) désactivée

On désactive la condition (Biscuit existe) étant donné que le programme suggèrera

qu’un seule fois le produit.

 Si (Règle 2 est active)

o Alors (Suggestion brosse à dents)
o Règle 1 inactive
o Règle 3 inactive
o (Suggestion brosse à dent) ajoutée à la trace de raisonnement
o (Dentifrice existe) désactivée
 Si (Règle 3 est active)
o Alors (Passage au sous-système expert petits articles)
o Règle 1 inactive
o Règle 2 inactive
o (Passage au sous-système expert petits articles) ajoutée à la trace de
raisonnement

Actions à faire :
 Si (Règle 1 active)
o Alors (Suggestion lait 0.5 L)
o Règle 1 inactive
o Trace de raisonnement affichée
 Si (Règle 2 active)
o Alors (Suggestion brosse à dents)
o Règle 2 inactive
o Trace de raisonnement affichée
 Si (Règle 3 active)
o Alors (Passage au sous-système petits articles)
o Règle 3 inactive
o Trace de raisonnement affichée

Programme avec le langage C :

Le programme décrivant ce système expert est le suivant :

D’abord une présentation des articles est une intéraction avec l’utilisateur constituent la
première fenêtre. Pour se faire :

#include <stdio.h>
#include <stdlib.h>

INTELLIGENT CONTROL - BAGGER 4

#include <stdbool.h>
#include <string.h>
#include <conio.h>
bool sacvide(int NbPAjoute)
{
while(NbPAjoute<4)
{
return true;
}
return false;
}
int main( )
{
char TableReglesPA[1000][1000]={"Mettre l'article dans le sac.\n", "Changer de
sac.\n"};
char TablesReglesSug[1000][1000]={"Suggestion Lait 0.5L \n", "Suggestion Brosse a
dents \n", "Passage au systeme expert PA \n"};
bool EtapePA=false;
bool existePA=false;
bool EtapeSug=false;
int NbPArt=0;
int Art=0;
int i=0;
char rep;
int j=0;
int NbPAjoute=0;
int sacn=1;
int r=0;
int k;
int p=0;
int e=0;
int PrioPA[10]={10,5};
bool ReglePA[10]={{false}};
bool RegleSG[10]={{false}};
char ArtDisp[7][50]={"Biscuits", "Lait 0.5L", "The", "Sucre", "Dentifrice", "Brosse a
dents", "Shampoing"};
bool ArtDispBool[7]={false};
char ArtAch[50][50]={{0}};
char TraceR[100][100];
char Table[50][50]={{0}};
printf(" Bienvenue dans Marjan (Binome 5)\n");

INTELLIGENT CONTROL - BAGGER 5

 printf(" ________________________________\n\n");
printf("Voici les petits articles disponibles actuellement:\n1. Biscuits\n2. Lait
0.5L\n3. The\n4. Sucre\n5. Dentifrice \n6. Brosse a dents\n7. Shampoing\n\n");
do {
printf ("Veuillez choisir un numero d'article.\n");
scanf ("%d", &Art);
getchar( ) ;
NbPArt += 1;
for (i=0; i<7; i++){
if (i==Art-1) {
strcpy(ArtAch[j], ArtDisp[i]);
}
}
j=j+1;
printf ("Voulez-vous ajouter un autre article?o/n\n");
scanf ("%c", &rep);
} while (rep=='o');
if (NbPArt>0) {existePA=true;}
printf("\nVous avez achete %d articles:\n\n", NbPArt);
for (i=0; i<NbPArt; i++){
puts(ArtAch[i]);
}
getch( );
system("cls");
int l=0;
for (i=0; i<7; i++) {
for (j=0; j<NbPArt; j++){
if (strcmp(ArtAch[j],ArtDisp[i])==0) {
strcpy(Table[l], ArtDisp[i]);
ArtDispBool[i]=true;
l+=1;
break;
}
}
}
getch( );

INTELLIGENT CONTROL - BAGGER 6

 Figure 1 : Fenêtre d’accueil du système expert Bagger

//activation des SSE

do {
e=e+1;
EtapeSug=true;
printf(" Sous Systeme Expert : Suggestion\n");
printf(" ________________________________\n\n\n");
printf("Etape %d:\n",e);
printf("________\n\n");
printf("Articles achetes:\n");
for (i=0; i<7; i++){puts(Table[i]);}
//Regles applicables
printf("Regles applicables:\n");
printf("___________________\n\n");
if (ArtDispBool[0] && !ArtDispBool[1]){
printf("Suggestion Lait 0.5L \n");
RegleSG[0]=true;
}
if (ArtDispBool[4] && !ArtDispBool[5]){
printf("Suggestion Brosse a dents \n");

INTELLIGENT CONTROL - BAGGER 7

 RegleSG[1]=true;
}
printf("Passage au systeme expert PA \n");
RegleSG[2]=true;
getch( );
//Priorites + regle elue
printf("\nRegle Elue:\n");
printf("_____________\n\n");
for (i=0; i<3; i++){
if(RegleSG[i]){
puts(TablesReglesSug[i]);
for (j=0; j<3; j++){
if (j!=i){
RegleSG[j]=false;
}
}
strcpy(TraceR[r],TablesReglesSug[i]);
ArtDispBool[i]=false;
}
}
getch();
//Actions
printf("Actions a faire:\n");
printf("________________\n\n");
if(RegleSG[0]){
printf("Suggestion Lait 0.5L \n\n\n");
RegleSG[0]=false;
printf("Trace de raisonnement:\n");
printf("______________________\n");
for(p=0;p<r+1;p++){
puts(TraceR[p]);
}
}
if(RegleSG[1]){
printf("Suggestion Brosse a dents \n\n\n");
RegleSG[1]=false;
printf("Trace de raisonnement:\n");
printf("______________________\n");
for(p=0;p<r+1;p++){
puts(TraceR[p]);
}

INTELLIGENT CONTROL - BAGGER 8

 }
if(RegleSG[2]){
printf("Passage au systeme expert PA \n\n\n");
RegleSG[2]=false;
printf("Trace de raisonnement:\n");
printf("______________________\n");
for(p=0;p<r+1;p++){
puts(TraceR[p]);
}
EtapeSug=false;
}
r=r+1;
getch( );
system("cls");
} while(EtapeSug);

Figure 2 : 2ème étape du sous-système Suggestion

INTELLIGENT CONTROL - BAGGER 9

Sous-système expert petits articles :

La base de règles associée est la suivante :

 Règle 1 : Mettre l’article dans le sac

 Règle 2 : Changer de sac

Algorithme des règles applicables :

 Si (petit article existe)

o Si (Sac n’est pas vide)
 Alors (Mettre l’article dans le sac)
 Sinon
o Changer de sac

Priorité des règles :

Règle 1 > Règle 2

Algorithme de la règle élue :

 Si (petit article existe)
o Si (Règle i est active) && (Sa priorité est importante)
 Alors (priorité est donnée à la règle i)
o Règle i active
o Si (Règle i est active)
 Alors (Affichage de la règle i)
 L’autre règle est désactivée
 Trace de raisonnement est mise à jour

Actions à faire :
 Si (Règle 1 active)
o Alors (Mettre l’article dans le sac)
o Nombre de petits articles diminue de 1
o Nombre de petits articles ajoutés augmente de 1
o Règle 1 désactivée
o Trace de raisonnement affichée
 Si (Règle 2 active)
o Alors (Changer de sac)
o ‘Sacn’ incrémenté (passage au sac i+1)

INTELLIGENT CONTROL - BAGGER 10

 o Nombre de petits articles ajoutés est réinitialisé
o Règle 2 désactivée
o Trace de raisonnement affichée

Programme avec le langage C :

Le programme décrivant ce système expert est le suivant :

e=0 ;
do {
e=e+1;
printf(" Sous Systeme Expert : Petits Articles\n");
printf(" _____________________________________\n\n\n");
printf("Etat actuel :");
printf("\n_____________");
printf("\n%d petits articles restants.\n", NbPArt);
printf("Sac %d contient: %d article(s). \n",sacn,NbPAjoute);
printf("N.B: Les sacs ont une capacite de 4 petits articles.\n\n");
printf("Etape %d:\n\n",e);
EtapePA=true;
//Regles applicables
printf("Regles applicables:\n");
printf("___________________\n\n");
if (existePA) {
if (sacvide(NbPAjoute)) {
printf("Mettre l'article dans le sac %d.\n", sacn);
ReglePA[0]=true;
}
printf("Changer de sac.\n");
ReglePA[1]=true;
}
getch( );
//Priorites + regle elue
printf("\nRegle Elue pour cette etape\n");
printf("___________________________\n\n");
p=0;
for(i=0;i<10;i++){
if(p<PrioPA[i] && ReglePA[i]){p=PrioPA[i];k=i;}
}
ReglePA[k]=true;
if(ReglePA[0]){
printf("Mettre l'article dans le sac.\n\n\n");

INTELLIGENT CONTROL - BAGGER 11

 ReglePA[1]=false;
strcpy(TraceR[r],"Mettre petit article dans le sac");
}
if(ReglePA[1]){
printf("Changer de sac.\n\n\n");
ReglePA[0]=false;
strcpy(TraceR[r],"Changer de sac");
}
getch( );
//Actions
printf("Actions a faire:\n");
printf("________________\n\n");
if (ReglePA[0]){
NbPArt-=1;
NbPAjoute+=1;
printf("Mettre l'article dans le sac.\n\n\n");
ReglePA[0]=false;
printf("Trace de raisonnement:\n");
printf("______________________\n\n");
for(p=0;p<r+1;p++){
puts(TraceR[p]);
}
}
if (ReglePA[1]) {
sacn+=1;
NbPAjoute=0;
printf("Changer de sac.\n\n\n");
ReglePA[1]=false;
printf("Trace de raisonnement:\n");
printf("______________________\n\n");
for(p=0;p<r+1;p++){
puts(TraceR[p]);
}
}
r=r+1;
getch( );
system("cls");
if (NbPArt==0){EtapePA=false;}
} while(EtapePA);
system("cls");

INTELLIGENT CONTROL - BAGGER 12

return 0;
}

Figure 3 : passage à la 1ère étape du sous-système petits articles

INTELLIGENT CONTROL - BAGGER 13

 Figure 4 : étape correspondant au changement de sac

INTELLIGENT CONTROL - BAGGER 14

Bagger compliqué :

Sous-système expert suggestion :

La règle ajoutée est :

 Règle 4 : Suggestion sucre

Mise à jour de la base de règles :

Ajout d’une 4ème règle de le tableau de règles déclaré.
Nouvelle condition :
Si (Thé existe) && (Sucre n’existe pas)
Alors (Suggestion sucre)
Priorité de la règle :
Les règles concernant la nourriture ont une priorité supérieure à celle des autres types
de produits

Modifications effectuées sur le programme :

//Regles applicables
if (ArtDispBool[2] && !ArtDispBool[3]){
printf("Suggestion Sucre \n");
RegleSG[3]=true;
}
//priorite+regle elue
if(RegleSG[3]){
printf("Suggestion Sucre \n\n\n");
RegleSG[0]=false;
RegleSG[1]=false;
RegleSG[2]=false;
strcpy(TraceR[r],"Suggestion Sucre");
ArtDispBool[2]=false;
}
ATTENTION : La règle « suggestion sucre » doit être insérée après la suggestion lait 0.5 L
et avant la suggestion brosse à dents afin de conserver la priorité de chaque règle
//Actions
if(RegleSG[3]){
printf("Suggestion Sucre \n\n\n");
RegleSG[3]=false;
printf("Trace de raisonnement:\n");
printf("______________________\n");
INTELLIGENT CONTROL - BAGGER 15
 for(p=0;p<r+1;p++){
puts(TraceR[p]);
}
}

Sous-système expert petits articles :

La règle ajoutée est :

 Règle 3 : Mettre un isolant

Mise à jour de la base de règles :

Nouvelle condition :
Si (0<Nombre petits articles<4) && (Trace de raisonnement précédente !=Mettre un
isolant)
Alors (Mettre un isolant)
Règle 4 active
Priorité :
Cette règle a la priorité la plus importante
Action effectuée si cette règle est élue :
Mettre un isolant
Affichage de la trace de raisonnement
Règle désactivée

Modifications effectuées au programme :

//Regles applicables
if(NbPAjoute>0 && NbPAjoute<4 && strcmp(TraceR[r-1],"Mettre un isolant")!=0){
printf("Mettre isolant\n");
ReglePA[2]=true;
}
//Priorite+Regle elue
ATTENTION ! De même ici il faut déclarer la règle en premier lieu étant donné qu’elle a
la plus grande priorité
if(ReglePA[2]){
printf("Mettre un isolant.\n\n\n");
ReglePA[0]=false;
ReglePA[1]=false;
strcpy(TraceR[r],"Mettre un isolant");
}
//Actions
if (ReglePA[2]) {
printf("Mettre un isolant.\n\n\n");
INTELLIGENT CONTROL - BAGGER 16
 ReglePA[2]=false;
printf("Trace de raisonnement:\n");
printf("______________________\n\n");
for(p=0;p<r+1;p++){
puts(TraceR[p]);
}
}

Figure 5 : Fenêtre d’accueil du système expert Bagger compliqué

INTELLIGENT CONTROL - BAGGER 17

 Figure 6 : Nouvelle règle appliquée

A l’étape 1, la première règle appliquée est « suggestion sucre » étant donné qu’elle a la
priorité la plus grande.

INTELLIGENT CONTROL - BAGGER 18

 Figure 7 : passage au sous-système petits articles

INTELLIGENT CONTROL - BAGGER 19

 Figure 8 : sous-système petits-articles

INTELLIGENT CONTROL - BAGGER 20

 Figure 9 : Nouvelle règle affichée « mettre un isolant »

INTELLIGENT CONTROL - BAGGER 21

 Figure 10 : Changement de sac

La trace de raisonnement montre bien qu’après l’ajout de chaque article, un isolant est
mis dans le sac afin de séparer les produits.

INTELLIGENT CONTROL - BAGGER 22

 Figure 11 : Dernière étape

INTELLIGENT CONTROL - BAGGER 23

Conclusion

Le système expert, étant ouvert, permet la modification de la base de règles et de faits à

tout instant. Ceci, s’effectuant en ajoutant les règles dans les blocs correspondants tout
en respectant leurs priorités. Ainsi si l’on a plusieurs règles à ajouter, on pourra
facilement créer une boucle qui passera par un tableau de règles à chaque état et
appeler celles qui sont applicables, la règle élue ainsi que l’action appropriée.

En plus, ce TP nous a permis d’améliorer nos connaissances dans la programmation en

langage C.

INTELLIGENT CONTROL - BAGGER 24