Vous êtes sur la page 1sur 29

3ème AII

2015/2016

Intelligent Control
Rapport de LAB1 : BAGGER
Réalisé par : NADA BEN EL HOUSSAIN

Encadré par : M.TAALABI


Introduction

D'une manière générale, un système expert est un outil capable de reproduire les mécanismes
cognitifs d'un expert, dans un domaine particulier. Il s'agit de l'une des voies tentant d'aboutir à
l'intelligence artificielle.

Plus précisément, un système expert est un logiciel capable de répondre à des questions, en
effectuant un raisonnement à partir de faits et de règles connues. Il peut servir notamment comme
outil d'aide à la décision.

Un système expert se compose de 3 parties :

- une base de faits,


- une base de règles et
- un moteur d'inférence.

Ce TP va constituer une introduction à la réalisation d’un système expert. On va procéder à la


conception d’un système expert, dédié à un robot de mise en sac qui va opérer au sein d’un
supermarché, et ainsi, on va le doter d’un raisonnement proche de celui de l’humain, afin qu’il puisse
faire la distinction des produits, et les placer en sac de manière adéquate

Pour pouvoir faire la conception d’un système expert, il existe plusieurs outils de programmation, tel
que l’utilisation d’un constructeur de système expert, ou le recours à un langage dédié tel que LISP.
Pour notre cas, nous allons avoir recours à un langage procédurale qui est très répandu, et qui est
bien le langage C++.

Dans la suite de ce rapport, on va décrire les différentes étapes effectués afin de concevoir notre
système expert intitulé « Bagger ».
I- Description générale

Pour la conception de notre système expert, on aura recours à une heuristique qui est bien
importante, qui stipule que, pour pouvoir mettre les article en sac d’une manière adéquate, il faut
commencer par les articles les plus grands, puis procéder par les articles moyens et enfin les petits
articles.
En plus de la mise en sac, on va programmer un sous-système expert de suggestions, qui, en se
basant sur la nature des articles déjà choisis, il va suggérer d’autre article qui vont avec.
Notre programme sera décomposé comme suit :
- Sous-système expert « grands articles »
- Sous-système expert « articles moyens »
- Sous-système expert « petits article »
- Sous-système expert « suggestions »
Pour le cas trivial, on va se limiter à deux sous-systèmes experts qui sont les suivants :
- Sous-système « grands article » : pour mettre les grands articles en sac, tout en
respectant deux articles par sacs au maximum
- Sous-système « suggestions » : pour suggérer des articles.

II- Outil de développement

Pour ce TP, on va utiliser le langage C++.

C++ est un langage de programmation compilé, permettant la programmation sous de


multiples paradigmes comme la programmation procédurale, la programmation orientée objet et
la programmation générique. C’est l’un des langages de programmation les plus utilisés et les plus
populaires
Le C++ est libre, et n’appartient à personne, son utilisation ne fait donc pas appel à l’acquisition de
certains droits.

Pour l’environnement de développement, on aura recours à Code ::Blocks qui est un environnement
intégré libre.

L’utilisation du C++ était dans l’intention de pouvoir exploiter la notion des objets.

A savoir, concrètement, un objet est une structure de données valuées et cachées qui répond à un
ensemble de messages.

III- Décomposition du programme

1- Description des classes

On va travailler sur deux classes qui sont comme suit :


Article dont les attributs sont :

- Nom de l’article
- Taille de l’article

Règles dont les attributs sont :

- Nom de la règle
- Priorité
- Applicabilité (variable logique)
- Etape (ou sous-système expert) à laquelle la règle appartient

les méthodes (ou procédures) de cette classe constitue les partie « condition » des règles, pour la
partie « action », elle sera définit dans le main

2- Les sous-systèmes experts

Comme on l’a déjà mentionné, on va se contenter de la programmation de deux sous-systèmes


experts

Sous-système expert « suggestions »

Régles Priorité
Suggérer Lait 40
Suggérer Biscuit 30
Suggérer sauce 10
Suggérer Démêleur 5
Passage Grand article 3

Sous-systèmes expert « grand article »

Régles Priorités
Mettre dans sac 30
Changer de sac 20
Passage a article moyen 10

3- Fonctionnement du programme : Arbre de recherche

On va exposer cette partie le déroulement du raisonnement de notre programme, à travers un cas


traité avec un arbre de recherche
Supposons que les articles choisis initialement par l’utilisateur sont :

- Café
- Démêleur
- Boisson

Arbre du sous-système expert « suggestions »

Café
Suggérer lait Démêleur
Boisson

Café
Démêleur
Suggérer Biscuit Boisson
Lait
Passage Grand Article
Café
Démêleur
Boisson
Lait
Biscuit
Passage Grand Article

Passage Grand Article


Arbre du Sous-système « grand articles »

Café
Démêleur
Boisson
Lait
Biscuit
Mettre en sac

Café
Boisson
Lait Article Moyen
Biscuit

Mettre en sac Sac1 :


Démêleur Changer de sac
Café ; Lait
Biscuit

Sac1 : Article Moyen


Démêleur
Boisson Changer de sac
Changer de sac

Café ;
Lait
Article Moyen
Biscuit

Sac1 :2 Art
Sac2 :

Mettre en Sac

Café
Lait
Article Moyen Biscuit

Sac1 :2 art
Changer de sac Sac2 : Lait

Article Moyen
IV- Programmation

1- Définition des classes


Classe Article
#define DEF_ARTICLE

#include <string>

class article

{
public:
article(std::string nomArticle, std::string volume);
bool grand_article ();
bool moyen_article();
bool petit_article();
std::string getvolume() const;
std::string getnomArticle() const;

article() ;
std::string m_volume;

private:
std::string m_nomArticle;

};

//Méthodes

article::article() : m_nomArticle("unknown"), m_volume("unknown")


{

article::article(string nomArticle, string volume):


m_nomArticle(nomArticle), m_volume(volume)
{

string article::getvolume() const


{
return m_volume;
}
string article::getnomArticle() const
{
return m_nomArticle;
}
Classe Règle
#define DEF_REGLE

#include <string>

#include "article.h"

class regle
{
public:
regle();
regle(std::string nomregle, int priorite, bool applicable,
std::string etape);
void grand_a(std::string);
void suggerer_lait(std::string etape, article table[10]);
void suggerer_biscuit(std::string etape, article table[10]);
void suggerer_sauce(std::string etape, article table[10]);
void suggerer_demeleur(std::string etape, article table[10]);
void passage_grand_article(std::string etape);

void mettre_dans_sac(std::string etape, article table[10], int sac,


int items);
void changer_de_sac(std::string etape, article table[10], int sac,
int items);
bool getapplicable() const;
int getpriorite() const;
void initialiser ();

std::string m_nomregle;
private:

int m_priorite;
bool m_applicable;
std::string m_etape;

};

regle::regle() : m_nomregle("unknown"), m_priorite(100),


m_applicable(false), m_etape("unknown")
{

}
regle::regle(string nomregle, int priorite, bool applicable, string
etape): m_nomregle(nomregle), m_priorite(priorite),
m_applicable(applicable),
m_etape(etape)
{

}
bool regle::getapplicable() const
{
return m_applicable;
}

int regle::getpriorite() const


{
return m_priorite;
}

void regle::initialiser ()

{ m_applicable=false;

//=================sous systeme expert suggestion


void regle::suggerer_lait(string etape, article table[10])

{
if(etape=="suggestion"){
int i;

for (i=0; i<10; i++){

if (table[i].getnomArticle()=="lait"){
m_applicable=false;
return;
}
}

for (i=0; i<10; i++){

if (table[i].getnomArticle()=="cafe")
break;

}
if(i<10){
m_applicable=true;

}}
else m_applicable=false;

}
//============suggerer biscuit

void regle::suggerer_biscuit(string etape, article table[10])

{
if(etape=="suggestion"){
int i;
for (i=0; i<10; i++){

if (table[i].getnomArticle()=="biscuit"){
m_applicable=false;
return;
}
}

for (i=0; i<10; i++){

if (table[i].getnomArticle()=="lait"){
break;
}
}
if(i<10){
m_applicable=true;

}}
else m_applicable=false;

}
//==================suggerer sauce

void regle::suggerer_sauce(string etape, article table[10])

{
if(etape=="suggestion"){
int i;
for (i=0; i<10; i++){

if (table[i].getnomArticle()=="sauce"){
m_applicable=false;
return;
}
}

for (i=0; i<10; i++){

if (table[i].getnomArticle()=="pattes"){
break;
}
}
if(i<10){
m_applicable=true;
}}
else m_applicable=false;

}
//==================suggerer demeleur

void regle::suggerer_demeleur(string etape, article table[10])

{
if(etape=="suggestion"){
int i;
for (i=0; i<10; i++){

if (table[i].getnomArticle()=="demeleur"){
m_applicable=false;
return;
}
}

for (i=0; i<10; i++){

if (table[i].getnomArticle()=="shampoing"){
break;
}
}
if(i<10){
m_applicable=true;

}}
else m_applicable=false;

}
//=======passage grand article

void regle::passage_grand_article(string etape){


if(etape=="suggestion") m_applicable=true;

}
//==================grand article

void regle::mettre_dans_sac(string etape, article table[10], int


sac, int items)

{
if(etape=="grand article"){
int i;
for (i=0; i<10; i++){

if (table[i].grand_article()==true and items <2){


break;
}
}
if(i<10){
m_applicable=true;}
else m_applicable=false;

void regle::changer_de_sac(string etape, article table[10], int sac,


int items){

if(etape=="grand article"){
int i;
for (i=0; i<10; i++){

if (table[i].grand_article()==true){

break;
}
}
if(i<10){
m_applicable=true;}
else m_applicable=false;

main

int main() {
//============== Déclaration des variables

string etape;

article
chocolat("chocolat","petit"),
cafe("cafe", "petit"),
demeleur("demeleur","grand"),
shampoing("shampoing","grand"),
boisson("boisson", "grand");
article
lait("lait","grand"),
biscuit("biscuit","petit"),
tisanes("tisanes", "petit"),
pattes("pattes","grand"),
sauce("sauce", "petit");

article table[10];
table[0]=chocolat;
table[1]=cafe;
table[2]=demeleur;
table[3]=shampoing;
table[4]=boisson;
table[5]=lait;
table[6]=biscuit;
table[7]=tisanes;
table[8]=pattes;
table[9]=sauce;

//===================== Déclaration des règles

regle suggerer_lait("suggerer lait", 40, false, "suggestion");


regle suggerer_biscuit("suggerer biscuit", 30, false, "suggestion");
regle suggerer_sauce("suggerer sauce", 10, false, "suggestion");
regle suggerer_demeleur("suggerer demeleur", 5, false,
"suggestion");
regle passage_grand_article ("passage grand article", 3, false,
"suggestion" );

regle mettre_dans_sac("mettre dans sac", 30, false, "grand


article");
regle changer_de_sac ("changer de sac", 20, false, "grand article");
regle passage_a_article_moyen ("passage a article moyen", 10 ,false,
"grand article");

regle trace_raisonnement[20];
int indice=0;

//================== Affichage des articles disponibles


cout<<endl;
cout<<"\t\t------les articles disponibles sont:----- "<<endl;
cout<<endl;
cout<<endl;
cout<<"\t\tarticle \t\t\t\ttaille"<<endl;
cout<<endl;
cout<<endl;
for(int i=0; i<10; i++)
{
//string nom;
// nom=table[i].getnomArticle();
cout<<"\t\t"<<table[i].getnomArticle()<<"
\t\t\t\t"<<table[i].getvolume()<<endl;
cout<<endl;
cout<<"\t\t- - - - - - - - - - - - - - - - - - - - - - -"<<endl;
cout<<endl;
}
//================= Saisie des articles choisis

cout<<endl;
cout<<" Veuillez choisir des articles parmi la liste
precedente"<<endl;
cout<<endl;

article choisis[10];

string a="y";
int j=0;

while(a=="y"){
cout<<"\t\t";
string nom;
cin>>nom;

for(int i=0; i<10; i++){


if (nom==table[i].getnomArticle()){
// cout<<table[i].getnomArticle()<<endl;

choisis[j]=table[i];
// cout<<choisis[j].getnomArticle()<<endl;
}
}
cout<<endl;
cout<<" Voulez vous ajouter un article?[y/n] ";

cin>>a;
cout<<endl;
if(a=="n") {break;}
j++;

//====================== Affichage des articles choisis

}
cout<<endl;
cout<<" vous avez selectionné les articles suivants"<<endl;
cout<<endl;

int k=0;
do{
//string nom;
// nom=table[i].getnomArticle();
//int k=0;
cout<<"\t\t" << choisis[k].getnomArticle() <<endl;
cout<<endl;

k++;

}while(choisis[k].getnomArticle()!="unknown");
cout<<endl;
system("pause");

//============================= Implémentation des règles


// sous systeme expert suggestions

system("cls");
cout<<endl;
cout<<"\t\t\t-------- Suggestion --------"<<endl;
cout<<endl;
cout<<endl;

etape="suggestion";
int p;

do{

suggerer_lait.suggerer_lait(etape, choisis);
suggerer_biscuit.suggerer_biscuit(etape, choisis);
suggerer_sauce.suggerer_sauce(etape,choisis);
passage_grand_article.passage_grand_article(etape);
cout<<endl;
cout<<endl;
cout<<"\t\t\t------ Regles Applicables -------"<<endl;
cout<<endl;
cout<<endl;
if(suggerer_biscuit.getapplicable()==true)
cout<<"\t\t"<<suggerer_biscuit.m_nomregle<<endl<<endl;
if(suggerer_demeleur.getapplicable()==true)
cout<<"\t\t"<<suggerer_demeleur.m_nomregle<<endl<<endl;
if(suggerer_lait.getapplicable()==true)
cout<<"\t\t"<<suggerer_lait.m_nomregle<<endl<<endl;
if(suggerer_sauce.getapplicable()==true)
cout<<"\t\t"<<suggerer_sauce.m_nomregle<<endl<<endl;
if(passage_grand_article.getapplicable()==true)
cout<<"\t\t"<<passage_grand_article.m_nomregle<<endl<<endl;

system("pause");

//============================= Résolution des conflits

p=0;

if(suggerer_lait.getapplicable()==true and
suggerer_lait.getpriorite()>p)
p=suggerer_lait.getpriorite();
if(suggerer_biscuit.getapplicable()==true and
suggerer_biscuit.getpriorite()>p)
p=suggerer_biscuit.getpriorite();

if(suggerer_sauce.getapplicable()==true and
suggerer_sauce.getpriorite()>p)
p=suggerer_sauce.getpriorite();

if(suggerer_demeleur.getapplicable()==true and
suggerer_demeleur.getpriorite()>p)
p=suggerer_demeleur.getpriorite();

if(passage_grand_article.getapplicable()==true and
passage_grand_article.getpriorite()>p)
p=passage_grand_article.getpriorite();

if(suggerer_lait.getpriorite()<p){
suggerer_lait.initialiser();}

if(suggerer_biscuit.getpriorite()<p){
suggerer_biscuit.initialiser();}

if(suggerer_sauce.getpriorite()<p){
suggerer_sauce.initialiser();}

if(suggerer_demeleur.getpriorite()<p){
suggerer_demeleur.initialiser();}

if(passage_grand_article.getpriorite()<p){
passage_grand_article.initialiser();}

//=============== Application des regles

if (suggerer_lait.getapplicable()==true){

cout<<endl;
cout<<"\t\tvoulez vous prendre du lait? [y/n] " ;

cin>>a;
cout<<endl;
for(int i=0; i<10; i++)
if(choisis[i].getnomArticle()=="unknown") {
choisis[i]=lait;

break;
}

suggerer_lait.initialiser();

//============= application des regles

if (suggerer_biscuit.getapplicable()==true){
cout<<endl;
cout<<"\t\tvoulez vous prendre du biscuit? [y/n] ";
cin>>a;
cout<<endl;

for(int i=0; i<10; i++)


if(choisis[i].getnomArticle()=="unknown") {
choisis[i]=biscuit;

break;
}
suggerer_biscuit.initialiser();
}

//================= application des regles

if (suggerer_sauce.getapplicable()==true){

cout<<endl;
cout<<"\t\tvoulez vous prendre de la sauce? [y/n] " ;

cin>>a;
cout<<endl;

for(int i=0; i<10; i++)


if(choisis[i].getnomArticle()=="unknown") {
choisis[i]=sauce;

break;
}
suggerer_sauce.initialiser();

//============= application des regles


if (suggerer_demeleur.getapplicable()==true){

cout<<endl;
cout<<"\t\t\tvoudriez vous prendre un demeleur? [y/n] " ;

cin>>a;
cout<<endl;

for(int i=0; i<10; i++)


if(choisis[i].getnomArticle()=="unknown") {
choisis[i]=demeleur;

break;
}
suggerer_demeleur.initialiser();

//============= application des regles


if(passage_grand_article.getapplicable()==true){
passage_grand_article.initialiser(); p=0; }

if(p==0){
system("cls");
cout<<endl<<endl<<endl<<endl<<endl<<endl;

//==============Affichage des la liste finale des articles

cout<<endl;
cout<<" vous avez selectionner les articles suivants"<<endl;
cout<<endl<<endl;

k=0;

do{
//string nom;
// nom=table[i].getnomArticle();
//int k=0;
cout<<"\t\t"<< choisis[k].getnomArticle() <<endl;
cout<<endl;
k++;

}while(choisis[k].getnomArticle()!="unknown");

//cout<<p<<endl;

}while(p!=0);

system("pause");
system("cls");

//============== sous système grand article


system("cls");
cout<<endl;
cout<<"\t\t\t-------- Grand Article --------"<<endl;
cout<<endl;
cout<<endl;

int sac=0;
int item;
item=0;
int reste;
reste=k;
article misensac("misensac","indifini");
article entable;

etape="grand article";

do{
mettre_dans_sac.mettre_dans_sac(etape, choisis, sac, item);
changer_de_sac.changer_de_sac(etape,choisis,sac,item);
cout<<endl;
cout<<endl;
cout<<"\t\t\t------ Regles Applicables -------"<<endl;
cout<<endl;
cout<<endl;
if(mettre_dans_sac.getapplicable()==true)
cout<<"\t\t"<<mettre_dans_sac.m_nomregle<<endl<<endl;
if(changer_de_sac.getapplicable()==true)
cout<<"\t\t"<<changer_de_sac.m_nomregle<<endl<<endl;

system("pause");

//============Résolution conflit

p=0;
// cout<<p<<endl;

if(mettre_dans_sac.getpriorite()<p){
mettre_dans_sac.initialiser();}
else{if(mettre_dans_sac.getapplicable()==true and
mettre_dans_sac.getpriorite()>p)
p=mettre_dans_sac.getpriorite();}

if(changer_de_sac.getpriorite()<p){
changer_de_sac.initialiser();}
else{if(changer_de_sac.getapplicable()==true and
changer_de_sac.getpriorite()>p)
p=changer_de_sac.getpriorite();}

cout<<endl;
cout<<"\t\t\t------ Regle Elue -------"<<endl;
cout<<endl;
cout<<endl;
if(mettre_dans_sac.getapplicable()==true){
cout<<"\t\t"<<mettre_dans_sac.m_nomregle<<endl<<endl;
trace_raisonnement[indice]=mettre_dans_sac;
indice++;
}
if(changer_de_sac.getapplicable()==true){
cout<<"\t\t"<<changer_de_sac.m_nomregle<<endl<<endl;
trace_raisonnement[indice]=changer_de_sac;
indice++;
}

system("pause");

//==============appliquer regle mise en sac


{

int i;
if (mettre_dans_sac.getapplicable()==true){

for( i=0; i<10; i++)


if(choisis[i].grand_article()==true) {

choisis[i].m_volume="en sac";

break;
}

cout<<endl<<endl;
cout<<"========== "<<choisis[i].getnomArticle()<<" a ete mis en
sac"<<endl;
}
cout<<endl<<endl;
reste--;
item++;
system("pause");
system("cls");
cout<<endl;

{
int i=0;
int l=0;

cout<<"\t\t--article en sac 1-- "<<endl<<endl;


for( i=0 ; i<10 and l<2; i++){

if(choisis[i].getvolume()=="en sac"){
l++;
cout<<"\t\t"<<choisis[i].getnomArticle()<<endl<<endl;
}

} l=0;
cout<<endl;
if(i<10){
cout<<endl<<"\t\t--article en sac 2-- "<<endl<<endl;
for( i ; i<10 and l<2; i++){
l++;
if(choisis[i].getvolume()=="en sac"){

l++;
cout<<"\t\t"<<choisis[i].getnomArticle()<<endl<<endl;
}

}}
}

cout<<"\t\t--article sur table:--"<<endl<<endl;


for(int i=0; i<10; i++){
if(choisis[i].getvolume()!="unknown" and
choisis[i].getvolume()!="en sac")
cout<<endl<<"\t\t"<<choisis[i].getnomArticle()<<endl<<endl;
}

system("pause");

mettre_dans_sac.initialiser();
}

//================appliquer regle changer de sac

if (changer_de_sac.getapplicable()==true){

cout<<endl<<endl;
cout<<"==========le sac a ete change"<<endl;
cout<<endl<<endl;
reste--;
item=0;
sac++;

system("pause");

for(int i=0; i<10; i++)


if(choisis[i].grand_article()==true) {

break;
}
changer_de_sac.initialiser();
}
}while(p!=0);

system("pause");
system("cls");

//===================== Affichage de la trace du raisonnement


cout<<endl<<endl<<endl<<"\t\t ----- La trace de raisonnement-----
"<<endl<<endl;

for(int x=0; x<20 and trace_raisonnement[x].m_nomregle!="unknown";


x++)
cout<<"\t\t\t " <<trace_raisonnement[x].m_nomregle<<endl<<endl;

}
V- Etapes d’éxecution

Dans cette partie, nous allons exposer le fonctionnement du sous-système expert conçu

Lorsqu’on exécute le programme, on obtient tout d’abord une liste des produits disponibles

On fait entrer la liste des produit achetés.


Exécution du sous système suggestion

Après la résolution du conflit, le SE choisit une règle élue, qui est la suggestion du biscuit
dans ce cas
Le SE a mis à jour la liste des produit achetés
La seule règle applicable maintenant est « passage grand article », ainsi, on va commencer
l’exécution du sous-système expert « grand article »
Vers la fin de l’éxecution, une fenêtre résumant la trace de raisonnement est affichée.
Conclusion
Ce TP a constitué une occasion pour voir de prêt l’utilité des systèmes experts dans la vie
quotidienne.

Nous avons découvert la notion du langage procédurale, et aussi, son emploi dans la conception des
systèmes expert.

Nous avons pu développer un programme qui a la possibilité d’évoluer en ajoutant de nouvelle


règles, et ceci en les déclarant d’abord dans la classe adéquate, et en leur affectant la bonne priorité,
et ainsi vient l’étape de leur programmation.