Vous êtes sur la page 1sur 15

1

INTRODUCTION

De nos jours, sous d’autres cieux, l’application de l’intelligence artificielle ne


cesse pas de prendre des ampleurs dans les différents domaines de la vie courante afin de
faciliter des nombreuses tâches qu’un être humain pourrait se donner les peines d’exécuter.

C’est dans le but de nous faire appréhender les techniques utilisées pour résoudre
des problèmes liés à l’analyse, au traitement et l’apprentissage de connaissances ou à la
déduction des nouvelles connaissances à partir d’une base de fait et d’une base de
connaissances que ce présent travail a été réalisé, il nous a été demandé afin de mettre en
pratique toutes ces notions apprises dans le cours d’intelligence artificielle.

Ce présent séminaire exhibe l’implémentation du processus de raisonnement avec


différentes types de méthodes dont la méthode de chaînage avant et chaînage en arrière.

Enfin, faire aussi l’implémentation de différents types d’apprentissages dont


l’apprentissage non supervisé avec l’algorithme de Hebb et l’apprentissage supervisé avec
l’algorithme de Perceptron.
2

LES PROCESSUS DE RAISONNEMENT AVEC DIFFERENTES TYPES DE


METHODES

1. Méthode de chaînage avant

C’est une forme de réflexion qui est guidée par les données. En effet, le MI part
des données initiales et essaie d’en déduire des nouvelles qui permettront à leur tour de
déduire le but. Ceci signifie que l’on ne sélectionne au cours de la phase de filtrage que les
règles dont les conditions de la partie gauche (les prémices) sont vérifiées. Ensuite, à la phase
de résolution des conflits qui est appliquée à l’ensemble des règles sélectionnées, on
détermine les règles à utiliser en propriété. La base de faits sera mise à jour lors de la phase
d’exécution par application de la règle retenue. Ce processus se réitère jusqu'à ce que le but
soit atteint ou jusqu’à ce qu’aucune règle ne soit applicable. Le chaînage avant s’avère une
bonne stratégie dans les structures dont le système expert doit interpréter proposée.

 Les faits : un fait est représenté par une chaîne de caractères c’est-à-dire un ensemble
de symboles éventuellement séparé par des blancs. Cette représentation laisse à
l’expert la liberté pour construire une base de connaissances en langage clair et
accessible.
 Les règles : une règle se présente comme suit :
Si partie condition
Alors partie action
La partie condition est un ensemble de faits à vérifier et la partie action est un
ensemble de faits qui sont ajoutés à la base de faits lorsque la règle est déclenchée.

Ainsi lorsque la structure choisie est celle de tableau, on peut décrire les différents
champs d’une règle de manière suivante :

Règle

Champ « partie condition » : tableau,


Champ « partie action » : tableau,
Champ « active » : un booléen.
 La base de faits : c’est un ensemble de tous les faits relatifs à un domaine/ il s’agit
donc d’un tableau de faits et puisqu’un tableau est une structure fixe aux dimensions
prédéfinies, il est nécessaire d’avoir une variable qui indique le nombre de faits
réellement présent dans la base de faits. Cette variable est incrémentée chaque fois
qu’un fait est ajouté à la base de faits.
 La base de règles : c’est un ensemble de toutes les règles. Ce sera donc un tableau de
règles. Il est également nécessaire d’adjoindre une variable qui indique le nombre de
règles présentes dans la base de règles.
 Edition de la base : l’édition de la base de règle se fera selon les principes ci-après :
3

 L’expert crée un fichier de texte ayant pour nom, le nom de la base de règles
auquel on affecte une extension. La base de règles est ainsi sauvegardée dans
ce fichier.
 Représentation des connaissances à l’aide des pointeurs et des listes.
Une liste est une suite de cellules ayant chacune deux composants (l’objet lui-
même et un pointeur sur la cellule suivante c’est-à-dire l’accès l’objet suivant).
L’objet peut être un fait, une règle, une affirmation, etc. Il est possible
d’ajouter un nombre illimité de cellules la liste. Une liste se termine lorsque le
dernier pointeur indique la variable « nul » c’est-à-dire néant.

 Base de connaissance : un domaine majeur de L’intelligence artificielle relative à la


conception des systèmes à base de connaissances s’appelle Systèmes experts. Ces
systèmes sont construits notamment pour atteindre les performances d’un Expert
humain dans des connaissances limitées en exploitant un ensemble des connaissances.
Acquises par les experts dans ce domaine. C’est à partir de 1975 que ces systèmes sont
apparus et ont Eu un impact sur l’intelligence artificielle. Le terme système expert a
tendance à disparaître au profit du concept plus général ‘‘systèmes Basés sur la
connaissance’’ que l’on retrouve dans les différents domaines d’activités de
L’intelligence artificielle. Ces concepts sont fondés sur une séparation entre les
connaissances nécessaires pour Résoudre un problème et les mécanismes de
raisonnement qui exploitent ces connaissances. Elle est constituée de la base des faits
(B.F) et de la base des règles (B.R). Les faits sont des Connaissances assertion et les
règles sont des connaissances opératoires.

 La structure d’un fait : la nouvelle structure d’un fait devrait comprendre les
informations suivantes :
 Son libellé, qui est une chaine de caractères
 L’état de vérité du fait qui peut prendre quatre valeurs : vrai, faux, indéterminé,
ou encore inconnu.
 Un booléen qui permet de savoir si le fait est éditable ou non, c’est-à-dire si le
système doit prévenir l’utilisateur de la déduction de ce fait.
 Un booléen qui permet au système de savoir si le fait est demandable ou non,
c’est-à-dire s’il est logique de demander des renseignements sur ce fait
l’utilisateur lorsque le système a besoin.
 Un pointeur sur une règle qui permet de savoir quelle règle a permis de déduire
le fait, le pointeur valant « nul » si le fait est indéterminé ou s’il a été affirmé
par l’utilisateur.

 La structure de règles : la structure d’une règle comprend les mêmes champs que le
cas précédent de tableau, c’est-à-dire :
Champ « partie condition »
Champ « partie action »
Champ « active »
4

Cependant, la façon de les implémenter est différente et beaucoup plus performante.

 La partie condition est constituée d’une liste de cellules contenant


 Un pointeur sur la cellule suivante,
 Une affirmation c’est-à-dire : un pointeur sur un fait de la base de faits et un état de
vérité.

1er cheminement

Comme critère de choix : « la 1 ère règle applicable est la 1ére dans l’ordre
d’apparition dans la base de connaissances ». Donc à chaque itération l’ensemble des règles
est examiné et on retient les règles applicables parmi ces dernières. On applique l’une d’entre
elles selon les critères de résolution des conflits retenus. On itère jusqu’à ce que le but
recherché puisse être déduit.

2ème cheminement

On prend deux critères de choix ou de résolution des conflits : « La règle qui


parmi l’ensemble des règles applicables comporte le plus des conditions dans des prémisses ».
S’il s’arrive que le système ne peut pas différencier quelques règles (par exemple en cas
d’égalité) il prend la première règle dans l’ordre d’apparition de la base de connaissance.

 Algorithme du chaînage avant

ENTREE : BF, BR, FAD (Fait à Démonter : FAD)


DEBUT
TANT QUE
FAD n’est pas dans BF ET
Qu’il existe dans BR une règle applicable
FAIRE
Choisir une règle applicable R (étape de résolution des conflits)
BR= BR – R (désactivation de R)
BF= BF ∪ conclusion (déclenchement de la règle R, sa conclusion est ajoutée à la base
de faits)
FIN DU TANT QUE
SI FAD appartient à BF ALORS FAD est établi
SINON FAD n’est pas établi

Codes.
5

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace IA
{
public partial class Avant : Form
{
// string[] BF;
//string[] BR;
//string FAD;
BaseDeConnaissance bk = new BaseDeConnaissance();
BaseFaits basefai = new BaseFaits();
BaseRegles basereg = new BaseRegles();
Faits f = new Faits();
Regles r = new Regles();
int nombreRegle;
public Avant()
{
InitializeComponent();
if (this.ControlBox == true)
{
this.Hide();
Form1 f = new Form1();
f.Show();
}
}

private void Avant_Load(object sender, EventArgs e)


{
}
private void button2_Click(object sender, EventArgs e)
{
int x = 60;
nombreRegle = int.Parse(textBox4.Text);
for (int i = 0; i < nombreRegle; i++) {
Label l = new Label();
6

l.Text = "Action";
l.Top = x;
x +=10;
l.Left = 20;
}
}
}
}

2. Méthode de chaînage en arrière

Cette seconde stratégie de contrôle est dirigée par le but qu’il faut démonter. En
d’autres termes, le système cherche à établir. On a évalué la valeur de vérité de certains faits
qui sont appelés buts en hypothèses. Le moteur d’inférence prend alors le but final comme
hypothèse et tend de remonter aux faits pour le démontrer. Les règles sélectionnées sont celles
dont la conclusion correspond aux but recherché. Si toutes les prémisses sont connues, le but
est atteint. On connaît les valeurs de vérité du but. Si certaines prémisses ne sont pas connues,
elles deviennent elles – mêmes des sous - buts qu’il faut démontrer. Le système réitère le
processus jusqu’à ce que le but initial soit obtenu c’est – à - dire jusqu’à ce qu’il ne soit plus
possible de sélectionner les règles. L’échec survient lorsque le système ne peut plus
sélectionner les règles ni poser des questions à l’utilisateur.
7

LES ALGORITHMES DE DIFFERENTS TYPES D’APPRENSTISSAGES

1. L’algorithme d’Hebb

Cette règle, basée sur des données biologiques, modélise le fait que si des neurones, de part et
d'autre d'une synapse, sont activés de façon synchrone et répétée, la force de la connexion
synaptique va aller croissant.Il est à noter ici que l'apprentissage est localisé, c'est-à-dire que
la modification d'un poids synaptique ne dépend que de l'activation de deux neurones.
Un réseau de neurones formels est un modèle rudimentaire du cerveau humain,
chaque cellule Neuronale étant décrite comme une fonction à seuil Possédant une sortie et
dont les entrées sont Reliées à d'autres neurones.

Le but des réseaux de neurone n'est pas la simulation du cerveau, en effet, les
réseaux de Neurones formels ne sont pas un modèle de notre structure cérébrale mais plutôt
une métaphore. De fait, l'objectif des réseaux de neurones artificiels est d'essayer de récupérer
tout ou partie des fonctionnalités d'un cerveau telles que la capacité d'apprentissage, la
capacité de généralisation et la capacité d'adaptation. Un réseau de neurones reste encore en
partie aujourd'hui une boîte noire » de laquelle il reste difficile d'extraire les relations
pertinentes entre les variables. De ce pont de vue, le système n'a donc qu'un pouvoir explicatif
médiocre, contrairement aux systèmes experts qui sont capables de retracer le cheminement
minimum pour attendre le résultat. Le réseau de neurones a une propension naturelle à stocker
de la connaissance empirique et la rendre disponible à l'usage. L'analogie avec le cerveau
humain se fonde sur deux aspects : le premier concerne l'apprentissage, la connaissance étant
acquise par le réseau au travers d'un processus d'apprentissage ; le second concerne les poids
synaptiques, c'est-à-dire les connexions entre neurones, connues sous le nom de poids
synaptiques, servant à stocker de la connaissance.

 Le principe de fonctionnement du réseau de neurones est simple : on dispose d'une base


de connaissances constituée de couples (inputs, outputs) et on veut utiliser cette base
pour entraîner une mémoire informatique à raisonner en prenant comme référence cette
base empirique. La construction d'un réseau de neurones passe, en général, par quatre
étapes : La première est le choix des échantillons de données d'apprentissage : cette
étape est cruciale car elle va aider le concepteur à déterminer le type de réseau le plus
approprié pour résoudre son problème ;
 Ensuite vient l'élaboration de la structure du réseau, qui dépend étroitement du type des
échantillons ;
 L’avant-dernière phase consiste à calculer les pondérations optimales des différentes
liaisons, en utilisant un échantillon - la dernière étape est la validation : une fois le
réseau calculé, il faut procéder à des tests pour vérifier que le réseau réagit bien comme
on le souhaite.

Codes
8

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms
*/
public class Hebb {

private Cell [][] cell ;


private Ligne [] ligne;
private double [] w;
private double tab [][] ;
private GridPane grid;
private GridPane gridL;
private TextArea textArea;
private ArrayList <String> array;
public ScrollPane draw (int L, int C, double s){
array = new ArrayList<>();
textArea = new TextArea();
textArea.setMaxWidth(200);
cell = new Cell[L][C];
ligne = new Ligne[C];
grid = new GridPane();
gridL = new GridPane();

// gridL.setPrefSize(600, 500);
for(int i=0 ;i<L; i++){
for(int j=0; j<C; j++){
grid.add(cell[i][j]= new Cell(), j, i);
cell[0][j].setText("e"+j);
cell[0][j].setDisable(true);
}
}
for (int j = 0; j < C; j++) {
ligne[j]=new Ligne();
gridL.add(ligne [j], j, 0);
}
cell [0][cell[0].length-1].setText("d");
ligne[cell[0].length-1].setText("w");
ligne[cell[0].length-1].setDisable(true);
9

tab = new double[L][C];


w = new double [C];
Button btnExe = new Button("Executer");
btnExe.setOnAction(e ->{
hebb(L, C, s);
});
ScrollPane scroll = new ScrollPane();
BorderPane brd = new BorderPane();

brd.setCenter(grid);
brd.setTop(gridL);
brd.setBottom(btnExe);
brd.setRight(textArea);
brd.getStyleClass().add("gridBlack");
scroll.setContent(brd);
return scroll;
}
private void recuprerW(int C){
for(int j=0; j<C-1; j++){
w[j]=Double.parseDouble(ligne[j].getText());
Console.out.print("Les w="+w[j]+" ");
}
Console.out.println("");
}
//
private void hebb(int L, int C, double s){
for(int i=1 ;i<L; i++){
for(int j=0; j<C; j++){
tab[i][j]=Double.parseDouble(cell[i][j].getText());
Console.out.print(tab[i][j]+" ");
}
Console.out.println();

}
recuprerW(C);
//
double []wCopy = new double[w.length];

double a;
int compt, l, y=0;
int x=0;
ArrayList<Integer> verif =new ArrayList();
10

for( l=0; l<20; l++){

compt=0;
for(int i=1; i<L; i++){
if(verif.contains(i)){
continue;
}
}
}

2. l’algorithme de Perceptron

Codes
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms
*/
public class Perceptron {
private Cell [][] cell ;
private Ligne [] ligne;
private double [] w;
private double tab [][] ;
private GridPane grid;
private GridPane gridL;
private TextArea textArea;
private ArrayList <String> array;
public ScrollPane draw (int L, int C, double s, double mu){
array = new ArrayList<>();
textArea = new TextArea();
textArea.setMaxWidth(200);
cell = new Cell[L][C];
ligne = new Ligne[C];
grid = new GridPane();
gridL = new GridPane();
// grid.setMaxWidth(150);
// gridL.setMaxWidth(150);
// grid.setMaxHeight(150);
// gridL.setMaxHeight(150);
11

// grid.setMinWidth(150);
// gridL.setMinWidth(150);
//

// gridL.setPrefSize(600, 500);
for(int i=0 ;i<L; i++){
for(int j=0; j<C; j++){
grid.add(cell[i][j]= new Cell(), j, i);
cell[0][j].setText("e"+j);
cell[0][j].setDisable(true);
}
}
for (int j = 0; j < C; j++) {
ligne[j]=new Ligne();
gridL.add(ligne [j], j, 0);
}
cell [0][cell[0].length-1].setText("d");
ligne[cell[0].length-1].setText("w");
ligne[cell[0].length-1].setDisable(true);

tab = new double[L][C];


w = new double [C];
Button btnExe = new Button("Executer");
btnExe.setOnAction(e ->{
perceptron(L, C, s, mu);
});
ScrollPane scroll = new ScrollPane();
BorderPane brd = new BorderPane();

brd.setCenter(grid);
brd.setTop(gridL);
brd.setBottom(btnExe);
brd.setRight(textArea);
brd.getStyleClass().add("gridBlack");
scroll.setContent(brd);
return scroll;
}

public void recuprerW(int C){


for(int j=0; j<C-1; j++){
w[j]=Double.parseDouble(ligne[j].getText());
Console..out.print("Les w="+w[j]+" ");
}
Console.out.println("");
12

}
//
public void perceptron(int L, int C, double s, double mu){
for(int i=1 ;i<L; i++){
for(int j=0; j<C; j++){
tab[i][j]=Double.parseDouble(cell[i][j].getText());
Console.out.print(tab[i][j]+" ");
}
Console.out.println();

}
recuprerW(C);
//
double []wCopy = new double[w.length];

double a;
int compt, l, y=0;
int x=0;
ArrayList<Integer> verif =new ArrayList();

for( l=0; l<20; l++){

compt=0;
for(int i=1; i<L; i++){
if(verif.contains(i)){
continue;
}
// Console.out.println("iteration "+(++y));
array.add("iteration "+(++y)+"\n");
a=0;
for(int j = 0; j<C-1; j++){
a+= w[j]*tab[i][j];
Console.out.print(w[j]+"*"+tab[i][j]+"+");

a= a-s;
Console.out.println("a="+a);
array.add("a="+a+"\n");
if(a>0){
x=1;
}else{
x=-1;
}
13

}
}
14

CONCLUSION

Enfin, nous tenons à remercier infiniment en général le Professeur KASORO


MULENDA pour le cours d’Intelligence Artificielle et en particulier l’Assistant Denis
MAMBA pour les séances des Travaux pratiques.

Dans nos limites et prolongements, nous n’avons pas la prétention d’avoir abordé
et épuisé tous les aspects des questions liées à notre séminaire, cette étude laisse les portes
ouvertes à tout chercheur intéressé de s’y investir pour la répliquer ou l’approfondir. Nous ne
pouvons cependant clore le présent travail sans pour autant signaler que cette étude est une
œuvre humaine, voilà pourquoi nous accepterons d’assumer la responsabilité de toutes les
imperfections liées à sa demande et à sa rédaction.
15

TABLE DES MATIERES

INTRODUCTION......................................................................................................................1
LES PROCESSUS DE RAISONNEMENT AVEC DIFFERENTES TYPES DE METHODES
.....................................................................................................................................................2
1. Méthode de chaînage avant.................................................................................................2
2. Méthode de chaînage en arrière..........................................................................................6
LES ALGORITHMES DE DIFFERENTS TYPES D’APPRENSTISSAGES..........................7
1. L’algorithme d’Hebb...........................................................................................................7
2. l’algorithme de Perceptron................................................................................................10
CONCLUSION.........................................................................................................................13
TABLE DES MATIERES........................................................................................................14

Vous aimerez peut-être aussi