TPs Intelligence Artificielle ISIMa 2011

See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/266392354
Travaux Pratiques : Intelligence Artiﬁcielle
Book · July 2011

DOI: 10.13140/2.1.1703.8080
CITATIONS READS
0 19,080
1 author:
Maher Helaoui
Institut Supérieur d'Administration des Entreprises de Gafsa
24 PUBLICATIONS 16 CITATIONS
SEE PROFILE
Some of the authors of this publication are also working on these related projects:
How Machine can take decision? View project
Extended Shortest Path Problem View project
All content following this page was uploaded by Maher Helaoui on 05 October 2014.
The user has requested enhancement of the downloaded file.

Travaux Pratiques :
Intelligence
Artificielle
Enseignant : Maher Helaoui
Maher Helaoui a enseigné comme assistant contractuel à l’Institut Supérieur

d’Informatique de Mahdia, Université de Monastir, TUNISIE. (2006-2011).
Il est aussi chercheur en Intelligence Artificielle, au Pôle de Recherche en

Informatique du Centre (PRINCE), à la Faculté des Sciences de Monastir FSM.
Contact : maher.helaoui@gmail.com
Site : www.sites.google.com/site/maherhelaoui/Home/
(ISIMa 2011)
Intelligence artificielle Introduction à Matlab ISIMa 2011
Sommaire
Première partie : Introduction à Matlab ..................................................................... 2
TP1 Initiation Matlab ..................................................................................................... 3
Introduction ................................................................................................................. 3
Matlab comme interpréteur en ligne .......................................................................... 3
Un peu de méthode ...................................................................................................... 4
Ctrl-C Ctrl-V, M-files, fonctions : rationalisons notre travail .................................... 8
Fonctions...................................................................................................................... 9
TAF .............................................................................................................................. 9
Instructions et structures de contrôle ......................................................................... 9
Un peu plus sur la programmation ............................................................................10
Les figures ..................................................................................................................10
TAF .............................................................................................................................12
Deuxième partie : LES RESEAUX DE NEURONES ........................................................14
TP2 Ajustement de fonction et classification.................................................................15
Objectif ........................................................................................................................15
Présentation des réseaux de neurones.......................................................................15
TAF .............................................................................................................................16
TAF : Exemple Illustrative de Classification des fruits ............................................16
(Notes de Lecture) ......................................................................................................16
Fonctions d’ajustement ..............................................................................................17
TP3 Réseaux perceptron et règles d’apprentissage .......................................................31
Objectif ........................................................................................................................31
Modèle de Neurone .....................................................................................................31
TAF .............................................................................................................................33
Architecture ................................................................................................................34
Création d’un perceptron : TAF .................................................................................34
Simulation (sim) .........................................................................................................36
TAF .............................................................................................................................36
Initialization (init) : TAF ............................................................................................37
Régles d’aprentissage .................................................................................................37
Règles d’apprentissage du perceptron .......................................................................38
TAF .............................................................................................................................39
Troisième partie : La logique floue .............................................................................41
TP4 Utiliser un régulateur avec Matlab ........................................................................42
Exemple 0 Application avec Matlab ...........................................................................42
Exemple 1 Contrôle du niveau d'eau .........................................................................45
TAF : ...........................................................................................................................48
TP5 Exemple de Freinage ..............................................................................................50
TAF .............................................................................................................................54
Questions ................................................................................................................54
Références de base .........................................................................................................55
M.Helaoui
1
Intelligence artificielle Introduction à Matlab ISIMa 2011
Première partie :
Introduction à Matlab
M.Helaoui
2
Intelligence artificielle Initiation Matlab ISIMa 2011
TP1 Initiation Matlab

Introduction
Qu'est ce que Matlab ?

Matlab est un langage de programmation de haut niveau destiné au calcul scientifique.
On le trouve dans les applications de :
- calcul,
- développement d'algorithmes,
- modélisation et simulation,
- analyse et visualisation de données,
- création de graphiques scientifiques,
- création d'application avec interfaces utilisateurs.
Il existe un grand nombre de toolboxes, familles de fonctions étendant les fonctions de
base de Matlab à un certain type de problème. On trouve ainsi des toolboxes dans les
domaines du traitement du signal, de la commande des systèmes, des réseaux de
neurones, de la logique floue, des ondelettes, de la simulation, etc…
Démarrer Matlab
1. Trouvez Matlab sur votre ordinateur.
2. Démarrez le programme. Un certain nombre de fenêtres apparaissent. Les plus
importantes sont l'interpréteur en ligne et la fenêtre Help. Si cette dernière
n'apparaît pas, dans l'onglet Help sélectionnez Matlab Help.
C'est tout ; l'aide en ligne est extrêmement conviviale et permet d'acquérir tout seul la
maîtrise du logiciel…
Ce manuel se propose tout de même de décrire l'utilisation du logiciel pour une
utilisation en intelligence artificielle (La logique floue et les réseaux de neurones…).
Arrêter Matlab
Taper quit ou exit ou fermez les fenêtres.
A propos des versions

Le présent manuel a été rédigé avec Matlab 2009a sous les yeux. La plupart de ce qui est
écrit dans ce manuel s'applique néanmoins aux versions antérieures.
Matlab comme interpréteur en ligne
Premiers pas
Au lancement de Matlab, une fenêtre s'ouvre et propose le prompt >> : on est en
présence de l'interpréteur en ligne.
M.Helaoui
3
Premier essai
Taper 2+2 et appuyez sur envoi. L'affichage propose alors :
>> 2+2
ans =
4
>>
Bravo : Matlab sait résoudre des opérations
Deuxième essai
Taper a=2 et envoi. L'affichage propose :
>> a=2
a=
2
>>
Bravo : Matlab sait manipuler des objets.
Pour travailler en silence : taper a=2; L'affichage propose :
>>a=2;
>>
Troisième essai
Taper i^2. La réponse est :
>> i^2
ans =
-1
>>
Ouf. Matlab sait manipuler des nombres complexes voire compliqués.
Un peu de méthode
TAF.
Choisir un répertoire de travail (Nom de l’étudiant : Tous les exemples, les fichiers.m et
ou fichiers.mat, les figures… doivent être testés et enregistrés dans ce répertoire)
Avant toutes choses, choisir un répertoire de travail : c'est dans celui-ci que vous
stockerez vos fichiers personnels. Dans la barre de menu, utilisez File/Set Path…
Les expressions
La programmation en Matlab consiste en l'enchaînement d'expressions composées de
variables, de nombres, d’opérateurs et de fonctions.
• Variables
Il n'est pas nécessaire de déclarer le type ou la dimension des variables : Matlab choisit
selon le contexte.
M.Helaoui
4
Par exemple :
a=2.37
Crée la variable a de dimension 1 et lui attribue la valeur 2.37.
Autre exemple :
>> a(2)=1.5
a=
2.37 1.5
>>
reprend la variable a et modifie sa dimension : c'est maintenant un vecteur de dimension
2 dont la deuxième valeur vaut 1.5
• Nombres
Exemples de nombres :
3 -99 0.001
1.6e-20 1i -3.14j
3e5i
Les nombres ont jusqu'à 16 chiffres significatifs et doivent rester entre 10-308 et 10+308.
• Matrices
Exemple :
>> mamatrice=[1 2 3;4,5,6;7 8,9]
mamatrice =
1 2 3
4 5 6
7 8 9
>>
Les données sont entrées en ligne, séparées par des virgules ou des espaces. Les lignes
sont séparées par des point virgules.
• Opérateurs
+ Addition - Soustraction
* Multiplication / Division
ˆ Puissance ./ Division élément par
élément (matrices)
' Conjugué et transpose .* Multiplication
élément par élément
(matrices)
.' Transposée
Pour la liste des opérateurs disponibles, tapez help ops.
• Fonctions
Pour obtenir une liste des fonctions mathématiques élémentaires taper :
>>help elfun
M.Helaoui
5
Pour obtenir une liste des fonctions matricielles élémentaires taper :

>>help elmat
Pour obtenir la liste des fonctions d'une toolbox spécifique, par exemple signal toolbox
(traitement du signal) taper :
>>help signal
Bien sûr il est aussi possible de définir ses propres fonctions.
• Constantes
Un certain nombre de fonctions prédéfinies (sans arguments) renvoient les valeurs de
constantes usuelles :
pi 3.14159265358979
i unité imaginaire -1
j pareil que i
eps précision relative en virgule flottante : 2-52
realmin plus petit nombre en virgule flottante : 2-
1022
realmax plus grand nombre en virgule flottante :

2+1022
Inf Infini (résultat de 1/0 par exemple)
NaN Not A Number (résultat de 0/0 par exemple)
Attention : il est possible de réaffecter les valeurs de ces constantes (éviter d'utiliser i et j
comme indice dans les boucles de calcul, notamment).
Un petit jeu amusant : essayer Inf+Inf, Inf/0, Inf-Inf, realmax+eps, realmax*(1+eps),
etc…
Un peu plus sur les matrices

• Opérations sur les matrices et fonctions matricielles
Les additions, soustractions transposées et autres inversions de matrices (taper A^-1)
sont triviales.
Un élément de la matrice s'appelle avec les parenthèses. Par exemple A(1,3) renvoie
l'élément de la première ligne, troisième colonne. Attention : pas de colonne 0.
La concaténation de matrice est triviale, attention cependant à respecter les dimensions.
(Exemple : Z=[A,B;C,D])
L'opérateur : s'utilise de différentes manières :
- pour créer des listes. Par exemple 1:4 renvoie [1 2 3 4] et 1:2:5 renvoie [1 3 5].
- Pour faire appel à des sous-parties de matrices. Par exemple A(:,3) renvoie la
troisième colonne de A et A(1:2:k,3) renvoie les k premiers éléments impairs de la
troisième colonne de A…
- Pour supprimer une ligne ou une colonne. Par exemple X(2,:)=[] supprime la deuxième
ligne (et redimensionne donc la matrice)
• Stocker des matrices dans des fichiers
M.Helaoui
6
On utilise souvent des matrices de grandes dimensions (résultats de mesures par

exemple). Les données doivent alors être écrites sous forme de tableau, séparées par des
blancs et des fins de lignes dans un fichier.dat
Par exemple un fichier donnees.dat crée par n'importe quel éditeur de texte contient :
1.001 2.34 0.12
2.44431 2.2 2.0091
3.1 47 4.31112
La commande load donnees.dat charge le fichier sous matlab et crée la matrice données.
A l'inverse, disposant sous Matlab d'un tableau résultat par exemple, il est possible de le
stocker dans un fichier par la commande save fichier_resultat resultat. Il est alors stocké
sous forme binaire dans un fichier fichier_resultat.mat et récupérable par la commande
load. Pour créer un fichier texte1 (ressemblant au fichier donnees.dat par exemple)
utiliser la commande fwrite.
Les structures
Matlab permet de manipuler des données sous formes de structures : les données sont
rangées dans une arborescence et accessibles par des champs. L'exemple suivant permet
de comprendre comment créer une structure simple :
>> toto.tata=[1 2 3 4]
toto =
tata: [1 2 3 4]
>> toto.titi=2
toto =
tata: [1 2 3 4]
titi: 2
>> toto
toto =
tata: [1 2 3 4]
titi: 2
>>
La structure toto contient deux champs : tata (qui est un vecteur de dimension 4) et titi
(qui est un entier). Pour accéder à un élément de la structure, on utilise le point :
>> toto.tata
ans =
1 2 3 4
>>
Bien sûr, on peut imbriquer plus de deux champs et inclure des variables de nature
différentes. Ainsi le "papa du papa du papa de mon papa était un fameux pioupiou"2
donne :
>>papa.papa.papa.papa='fameux pioupiou';
1 Par exemple pour être traité par un autre logiciel comme Excel…
2 Paroles et musique Boby Lapointe
M.Helaoui
7
Ctrl-C Ctrl-V, M-files, fonctions : rationalisons notre travail
Historique
Les flèches de direction (←↑→↓) permettent de retrouver et modifier les lignes de
commandes précédentes.
La version 2009a de Matlab propose une fenêtre command history qui garde en mémoire
les commandes passées dans la session courante et dans les sessions précédentes.
Copier-Coller (Ctrl-C Ctrl-V)

En pratique on tape les commandes directement dans la fenêtre de l'interpréteur pour de
petits calculs. Lorsque cela devient plus sérieux il est beaucoup plus rentable d'utiliser
un éditeur de texte pour entrer les expressions (séparées par des retours à la ligne) puis
de copier-coller dans la fenêtre Matlab. L'éditeur de texte le plus commode est alors celui
de Matlab : dans la barre de menu File / New / M-file.
Scripts
L'étape suivante consiste à créer des scripts : il s'agit de fichiers textes comprenant un
ensemble de commandes. Pour cela le plus simple consiste à utiliser l'éditeur/Debugger
de Matlab.
Créons par exemple un nouveau script :
File / New / M-file
Puis écrivons la séquence de commande qui nous intéresse :
%Mon premier script
a=2;
b=3;
a+b
Sauvegardons ce script dans un fichier : File / Save As puis choisir un nom de fichier, par
exemple essai. Notons que Matlab ajoute l'extension .m par défaut.
Pour lancer le script depuis Matlab il suffit de taper son nom essai sans l'extension .m.
L'affichage propose alors :
>> essai
ans=
5
>>
Deux remarques :
1. La ligne précédée du caractère % n'a pas été interprétée : il s'agit d'une ligne de
commentaires.
2. Seule les expressions qui ne sont pas terminées par un point virgule ( ; ) sont visibles
dans la fenêtre de l'interpréteur.
M.Helaoui
8
Fonctions
Les M-files permettent aussi de définir des fonctions. A la différence des scripts, les
variables définies dans une fonction sont locales. Examinons par exemple le m-file
comportant les lignes d'instruction suivantes :
function Maxi = Moyenne(Note_2009, Note_2008)

%Cette fonction retourne le maximum des notes entre 2008 et 2009
d'un %etudiant
Maxi=max(Note_2009, Note_2008);
TAF
1. Developper, Moyenne.m la fonction
function Moy = Moyenne(n, Note_2009, Note_2008, coef)
%Cette fonction permet le calcul de la moyenne d'un etudiant tel que
n %est le nombre de notes, Note_200X est l’ensemble des notes
obtenues en %200X et coef est l’ensemble des coefficients.
2. Créer les données suivant :

Dans Najah.m enregistrer les données de Najah
n =10,
Note_2009 = [9 9 9 9 9 9 9 9 9 9],
Note_2008 =[8 11 8 11 11 8 11 8 11 11],
Coef =[2 3 2 3 3 2 3 2 3 3].
La commande >> Najah

Doit retourner la moyenne de Najah.
Dans Raceb.m enregistrer les données de Raceb
n =10,
Note_2009 = [9 9 9 9 9 9 9 9 9 9],
Note_2008 =[8 10 8 10 10 8 10 8 10 10],
Coef =[2 3 2 3 3 2 3 2 3 3].
La commande >> Raceb

Doit retourner la moyenne de Raceb.
Instructions et structures de contrôle

Matlab dispose d'un certain nombre d'instructions de contrôle :
- if
- switch
- for
- while
- continue
- break
Pour la syntaxe exacte et pour des exemples, utiliser l'aide en ligne : help if (par
exemple).
M.Helaoui
9
Il est parfois possible de réduire le temps de calcul en utilisant la vectorisation.

Examinons par exemple les lignes suivantes :
A=1:1:100;
for ii=1:1:100
B(ii)=sin(A(ii));
end;
Ces lignes sont strictement équivalentes à :
A=1:1:100;
B=sin(A);
Le résultat produit est le même que dans la première version, le temps de calcul plus
court et la lisibilité améliorée.
Un peu plus sur la programmation

Le programmeur en Java ou C++ sera rassuré de savoir que le langage de
programmation de Matlab est aussi orienté-objet. Le lecteur qui vient de lire ces lignes
et qui n'a rien compris est invité à attendre les cours d'informatique.
Les figures
Matlab permet de créer des graphiques complexes et d'en contrôler les moindres détails.
Ce chapitre donne l'essentiel à savoir ainsi que quelques clefs pour aller plus loin.
Tracer des courbes et créer une figure

La séquence d'instruction suivante crée d'abord une figure puis place les commentaires
sur les deux axes et enfin une ligne de titre :
>> x=0:pi/100:pi;
>>y=sin(x);
>>plot(x,y);
>>xlabel('x = 0:2\pi');
>>ylabel('sinus de x');
>>title('sinusoïde','Fontsize',12);
La figure suivante apparaît dans une nouvelle fenêtre :
M.Helaoui
10
sinusoïde
1
0.8
0.6
0.4
0.2
sinus de x
-0.2
-0.4
-0.6
-0.8
-1
0 1 2 3 4 5 6 7
x = 0:2π
Style et couleurs des lignes

Il est possible de choisir le style et la couleur des lignes avec la commande plot :
plot(x,y,'color_style_marker'). 'color_style_marker' est une chaîne de caractère
comportant jusqu'à quatre caractères :
• Couleur : 'c', 'm', 'y', 'r', 'g', 'b', 'w'
• Style de ligne : '-', '--', ':', '-.', 'none'
• Type de ligne : '+', 'o', '*', 'x', 's' (square), 'd' (diamond), etc…
La variable 'color_style_marker' peut par exemple prendre la valeur 'y-o' pour que le
tracé soit jaune et constitué de ronds reliés par un trait continu.
Superposer des courbes

La fonction plot admet un nombre indéfini d'arguments et permet de superposer dans
une même figure plusieurs courbes.
Essayer par exemple : plot(x,y,x,y*2)
Variables complexes
Si Z est un vecteur de nombre complexes la fonction plot(Z) est équivalente à
plot(real(Z),imag(Z)).
Ajouter des courbes à une figure existante

La commande hold on permet de conserver la figure courante : le tracé suivant ne se fait
pas dans une nouvelle fenêtre mais se superpose au tracé précédent (en adaptant
éventuellement les échelles).
Plusieurs courbes dans une même fenêtre

La commande subplot permet de partitionner la fenêtre de la figure et de tracer
plusieurs courbes. Considérons l'exemple suivant :
» x=0:pi/100:pi*2;
M.Helaoui
11
» subplot(2,2,1);plot(x,sin(x);
» subplot(2,2,1);plot(x,sin(x));
» subplot(2,2,2);plot(x,cos(x));
» subplot(2,1,2);plot(x,cos(x).*cos(x));
La figure créée est reproduite ci-après :
1 1
0.5 0.5
0 0
-0.5 -0.5
-1 -1
0 2 4 6 8 0 2 4 6 8
0.8
0.6
0.4
0.2
0
0 1 2 3 4 5 6 7
Le premier subplot partitionne en deux lignes et deux colonnes et place le pointeur sur la
première case. Le second subplot partitionne de la même manière et place le pointeur sur
la deuxième case. Le troisième subplot partitionne en deux lignes et une seule colonne et
place le pointeur sur la deuxième case (la deuxième ligne).
Placer des titres et des commentaires

Les commandes xlabel, ylabel, title, text permettent de commenter les axes x, y, de
placer un titre au graphique ou de placer un commentaire n'importe où sur le graphique.
TAF
1. Tracer dans le même graphe dans un premier subplot les notes de Najah en 2008
et en 2009, et dans un second subplot les notes de Raceb en 2008 et en 2009.
Un peu plus sur les graphiques

Une fois le graphique créé, il est possible de rajouter des titres, des commentaires, etc...
en utilisant la fonction Tools / Edit Plot de la barre de menu de la fenêtre graphique.
De manière plus générale, et cela sort du cadre de ce manuel, les données décrivant
l'ensemble d'un graphique sont stockées sous la forme d'une structure. Il est donc
possible de pointer directement sur un élément d'un graphique (axe, titre, donnée, etc…)
et de le modifier en utilisant des fonctions spécialisées. Pour plus de détails consulter
l'aide de Matlab.
M.Helaoui
12
Références
http://www.mathworks.com/ LA société Mathworks, qui développe et commercialise Matlab
http://pauillac.inria.fr/cdrom/www/scilab/fra.htm La page officielle de Scilab
M.Helaoui
13
Intelligence artificielle Les réseaux de neurones ISIMa 2011
DEUXIEME PARTIE :
LES RESEAUX DE
NEURONES
M.Helaoui
14
Intelligence artificielle Ajustement de fonctions et classification ISIMa 2011
TP2 Ajustement de
fonction et
classification
Objectif
Ce TP explique comment utiliser deux outils graphiques : l’ajustement de fonctions et la
classification. Ceci pour résoudre des problèmes en appliquant la technique des réseaux de neurones.
L'utilisation de ces deux techniques nous donnera une excellente introduction à l'utilisation de la boîte
à outils des réseaux de neurones (neural network toolbox™ software).
Présentation des réseaux de neurones

Les réseaux de neurones sont composés par des éléments simples fonctionnant en parallèle. Ces
éléments sont inspirés par des systèmes nerveux biologiques. Comme dans la nature, les connexions
entre ces éléments déterminent en grande partie la fonction de réseau. Nous pouvons exploiter un
réseau de neurone pour exécuter une fonction particulière en ajustant les valeurs (paramètres) des
connexions (des poids) entre ces éléments.
Typiquement, les réseaux de neurones sont ajustés, ou formés, pour qu'un objet entré (input) mène à
une production cible (target) spécifique. La figure ci dessous illustre une telle situation.
Le réseau est ajusté en se basant sur une comparaison de la production et la cible (target), jusqu'à ce
que la production de réseau corresponde à la cible (target). Typiquement plusieurs tel paires
Entré/Cible (Input/Target) sont nécessaires pour former un réseau.
M.Helaoui
15
Les réseaux de neurones ont été formés pour exécuter des fonctions complexes dans des divers
domaines, comme la reconnaissance de formes, l'identification, la classification, le discours, la
vision et des systèmes de commande.
TAF
- Décrire le rôle des réseaux de neurones en se basant sur la figure ci-dessus.
TAF : Exemple Illustrative de Classification des fruits

- Dans la command window tapez:
>> nnd3pc
- Cliquer sur Go
- Décrire l’exemple.
- Que fera la machine pour classer le fruit ?
- Quelle est la méthode ou technique de classification utilisée ?
- Présenter une modélisation et une description de cette technique.
- Comment cette technique pourra décider pour classifier le fruit ?
- Ecrire un algorithme qui résume cette technique de classification (préciser la règle de
décision)
- Il est possible d’utiliser d’autres techniques : dans la command window tapez:

>> nnd3hamc
- Quelle est la nouvelle technique de classification utilisée ?
- Présenter une modélisation et une description de cette deuxième technique.
- Comment cette nouvelle technique pourra décider pour classifier le fruit ?
décision)
- Dans la command window tapez:

>>nnd3hopc
- Quelle est la nouvelle technique de classification utilisée ?

- Présenter une modélisation et une description de cette deuxième technique.
- Comment cette nouvelle technique pourra décider pour classifier le fruit ?
décision)
- Comment nous pouvons comparer l’efficacité de ces trois techniques ?
- Définir les réseaux de neurones en présentant leur apport pour l’Intelligence Artificielle.
(Notes de Lecture)
Les réseaux de neurones peuvent aussi être utilisés pour résoudre des problèmes qui sont difficiles
même pour des ordinateurs conventionnels ou pour des êtres humains. La boîte à outils souligne
l'utilisation des réseaux de neurones dans l’ingénierie, la finance et d'autres applications pratiques.
M.Helaoui
16
Fonctions d’ajustement
Supposons, par exemple, que nous avons des données d'une demande de logement
[HaRu78]. Nous voulons concevoir un réseau qui peut prévoir la valeur d'une maison, étant
donné 13 pièces d'informations géographiques et immobilières. Nous avons un total de 506
exemples de maisons pour lesquelles nous avons ces 13 packs de données.
Présentation du problème
Pour définir un problème à la boîte à outils, arrangeons un ensemble de vecteurs

d'entrés Q (input) comme des colonnes dans une matrice. Ensuite, arrangeons un autre
ensemble de vecteurs T cible de Q dans une deuxième matrice. Par exemple, nous pouvons
définir le problème d’ajustement du Booléen ET portant sur quatre ensembles à deux éléments
de vecteurs d'entrés et un élément de cible comme suit :
>>Q = [0 1 0 1; 0 0 1 1];
>>T = [0 0 0 1];
La sous section suivante démontre comment apprendre à un réseau d’adapter un ensemble de

données, utilisant l'outil d'ajustement de réseau de neurone, nftool. Cet exemple utilise
l’ensemble de données de logement fourni avec la boîte à outil.
Utilisation de l'Outil d'Ajustement de Réseau de Neurone
1 Ouvrir l’outil d’ajustement en tapant:
>>nftool
M.Helaoui
17
2 Cliquer Next pour procéder.
3 Cliquer Load Example Data Set dans la fenêtre Select Data. La fenêtre Fitting Data Set Chooser
s’ouvre.
Noter Utiliser les options d’entrés (Inputs) et cibles (Targets) dans la fenêtre Select Data lorsque
vous avez besoin d’importer des donnés de MATLAB workspace.
4 Selectionner House Pricing, et cliquer Import. Ceci retourne la fenêtre Select Data.
5 Cliquer Next pour afficher la fenêtre Validation and Test Data, voir la figure ci-dessous.
Les ensembles Validation et test data prennent chacun 15% comme valeurs d’origine.
M.Helaoui
18
Avec ces fixations de donnés, les vecteurs d'entrés et les vecteurs cibles seront aléatoirement divisés
dans trois ensembles comme suit :
•70% sera utilisé pour la formation (training).
•15% sera utilisé pour valider le réseau généralisé et arrêter la formation auparavant de l'ajustement.
•Les 15% restante sera utilisée comme un test complètement indépendant de la généralisation de
réseau.
6 Cliquer Next.
Le réseau standard qui est utilisé pour l'ajustement de fonction est un réseau feedforward à deux
couches, avec une fonction de transfert de sigmoid dans la couche cachée et une fonction de transfert
linéaire dans la couche de production. Le nombre par défaut de neurones cachés est mis à 10. Vous
pourriez augmenter ce nombre plus tard, si le réseau formant la performance est pauvre.
M.Helaoui
19
7 Cliquer Next.
8 Cliquer Train.
La formation continue jusqu'à l’échec de l'erreur de validation à diminuer durant six itérations (l'arrêt
de validation).
M.Helaoui
20
9 Cliquer Régression. Ceci est utilisé pour valider la performance de réseau.

Les représentations de régression suivantes montrent les productions de réseau en respectant les cibles
formés, la validation et les testes des ensembles. Pour une crise parfaite, les données devraient chuter
le long de 45 degré, où les productions de réseau sont égales aux cibles. Pour ce problème, la crise est
raisonnablement bonne pour tous les ensembles de données, avec des valeurs de R de 0.93 dans
chaque cas. Si des résultats encore plus précis ont été exigés, vous pourriez recycler le réseau par
cliquer Recyclent dans nftool. Cela changera les poids initiaux et les préventions du réseau et peut
produire un réseau amélioré après Retraining. On fournit d'autres options sur le carreau suivant.
M.Helaoui
21
10 Considérez l'histogramme d'erreur pour obtenir une vérification supplémentaire de la performance

de réseau. Sur le Plots pane, cliquer Error Histogram.
M.Helaoui
22
Les barres bleues représentent des données de formation, les barres vertes représentent des données de
validation et les barres rouges représentent des données de test. L'histogramme peut vous donner une
indication d'outliers, qui sont des points de données où la crise est significativement plus mauvaise que
la majorité de données. Dans ce cas, vous pouvez voir que tandis que la plupart d'erreurs chutent entre
-5 et 5, c’est un point de formation avec une erreur de 17 et des points de validation avec des erreurs
de 12 et 13. Ces outliers sont aussi visibles sur le complot de régression de test. Le premier correspond
au point avec une cible de 50 et la production près de 33. C'est une bonne idée de vérifier l'outliers
pour déterminer si les données sont mauvaises, ou si ces points de données sont différents que le reste
d’ensemble de données. Si l'outliers sont des points de données valables, mais elles sont différentes du
reste des données, donc le réseau extrapole pour ces points. Vous devriez rassembler plus de données
qui ressemblent aux points d'outlier et recycler le réseau.
11 Cliquer Ensuite dans l'Outil d'Ajustement de Réseau de Neurone pour évaluer le réseau.
M.Helaoui
23
À ce point, vous pouvez tester le réseau contre de nouvelles données. Si vous êtes peu satisfaits avec la
performance du réseau sur les données originales ou nouvelles, vous pouvez faire une des choses
suivantes :
·Train de nouveau.
·Augmenter le numéro de neurones.
·Choisir un ensemble plus grand de données de formation.
Si la performance sur l’ensemble de formation est bonne, mais la performance de l’ensemble de test
est significativement plus mauvaise, qui pourrait indiquer le sur ajustement, donc la réduction du
nombre de neurones peut améliorer vos résultats. En formant une performance faible, alors vous
pouvez augmenter le nombre de neurones.
12 si vous êtes satisfaits de la performance de réseau, cliquez Next.
13 Utilisez les boutons sur cet écran pour produire d’autres scénarios ou sauvegarder vos résultats.
M.Helaoui
24
- Vous pouvez cliquer sur le Simple Script ou Advanced Script pour créer le code MATLAB ® qui
peut être utilisé pour reproduire tous les étapes précédents de la ligne de commande. La création du
code MATLAB ® peut être utile si vous voulez apprendre comment utilisez la fonctionnalité de ligne
de commande de la boîte à outils pour personnaliser le processus de formation.
- Vous pouvez aussi faire sauver le réseau comme le réseau dans l'espace de travail. Vous pouvez y
exécuter des tests supplémentaires ou le mettre pour travailler sur de nouveaux entrés.
14 Quand vous avez créé le code MATLAB ® et après avoir sauvegardé vos résultats, cliquer Finish.
Comment utiliser la fonctionalité de la ligne de commande
La façon la plus facile d'apprendre comment utiliser la fonctionnalité de ligne de commande

de la boîte à outils est de produire des scénarios du GUIS et les modifier ensuite pour personnaliser la
formation de réseau. Comme un exemple, regardez le scénario simple qui a été créé à l'étape 13 de la
section précédente.
% Solve an Input-Output Fitting problem with a Neural Network

% Script generated by NFTOOL
%
% This script assumes these variables are defined:
%
% houseInputs - input data.
% houseTargets - target data.
inputs = houseInputs;
targets = houseTargets;
% Create a Fitting Network
hiddenLayerSize = 10;
net = fitnet(hiddenLayerSize);
M.Helaoui
25
% Set up Division of Data for Training, Validation, Testing

net.divideParam.trainRatio = 70/100;
net.divideParam.valRatio = 15/100;
net.divideParam.testRatio = 15/100;
% Train the Network
[net,tr] = train(net,inputs,targets);
% Test the Network
outputs = net(inputs);
errors = gsubtract(outputs,targets);
performance = perform(net,targets,outputs)
% View the Network
view(net)
% Plots
% Uncomment these lines to enable various plots.
%figure, plotperform(tr)
%figure, plottrainstate(tr)
%figure, plotfit(targets,outputs)
%figure, plotregression(targets,outputs)
%figure, ploterrhist(errors)
Vous pouvez sauvegarder le scénario et l'exécuter ensuite de la ligne de commande pour vous
reproduire les résultats de la session GUI précédente. Vous pouvez aussi éditer le scénario à
personnaliser le processus de formation. Dans ce cas, suivez chaque scénario.
0 le scénario suppose que les vecteurs d'entrés et les vecteurs cibles sont déjà chargés dans l'espace de
travail. Si les données ne sont pas chargées, vous pouvez les charger comme Suit :
load house_dataset
inputs = houseInputs;
targets = houseTargets;
Cet ensemble de données est un des ensembles de données types qui fait partie de la boîte à outils.
Vous pouvez voir une liste de tous les ensembles de données disponibles en entrant à la commande
help nndatasets.
La commande de chargement vous permet aussi de charger les variables de n'importe quel de ces
ensembles de données utilisant votre propre nom de variable.
Par exemple, la commande
[inputs,targets] = house_dataset;
1 Créez un réseau. Le réseau par défaut pour ajustement de fonction (ou régression) les problèmes,
fitnet, sont un réseau feedforward avec le bronzage-sigmoid par défaut la fonction de transfert dans la
couche cachée et le transfert linéaire fonctionne dans la couche de production. Vous avez assigné dix
neurones (quelque peu arbitraire) à celui couche cachée dans la section précédente. Le réseau a un
neurone de production, parce qu'il y a seulement une valeur cible associée à chaque vecteur d’entrés.
hiddenLayerSize = 10;
net = fitnet(hiddenLayerSize);
2 Fondez la division de données.
net.divideParam.trainRatio = 70/100;
net.divideParam.valRatio = 15/100;
net.divideParam.testRatio = 15/100;
Avec ces fixations, les vecteurs d'entrés et les vecteurs cibles seront aléatoirement divisés, avec 70 %
utilisés pour la formation, 15 % pour la validation et 15 % pour le test.
M.Helaoui
26
3 Formez le réseau. Le réseau utilise par défaut l’algorthme de Levenberg-Marquardt pour la

formation the network (trainlm). Pour former le réseau, entrer:
[net,tr] = train(net,inputs,targets);
Pendant la formation, la fenêtre de formation suivante s'ouvre. Ces affichages de fenêtre formant le
progrès et vous permettent d'interrompre la formation à n'importe quel point en cliquant Stop
Training.
Cette formation s'est arrêtée quand l'erreur de validation a augmenté durant six itérations, ce qui se
fera à l'itération 23. Si vous cliquez Performance dans la fenêtre de formation, Un affichage des
erreurs d’une formation, des erreurs de validation et des erreurs de test apparaît, comme indiqué dans
la figure suivante.
Dans cet exemple, le résultat est raisonnable à cause des considérations suivantes :
·L'erreur carrée moyenne finale est petite.
·L'erreur de l’ensemble test et l’erreur de l’ensemble validation ont des caractéristiques semblables.
M.Helaoui
27
·Pas de surajustement significatif obtenu par l'itération 17 (où on a obtenu la meilleure performance de
validation).
4 Testez le réseau. Après que le réseau a été formé, vous pouvez l'utiliser pour calculer les productions
de réseau. Le code suivant calcule les productions de réseau, des erreurs et la performance complète.
outputs = net(inputs);
errors = gsubtract(targets,outputs);
performance = perform(net,targets,outputs)
Il est aussi possible de calculer la performance de réseau seulement sur l’ensemble de test, en utilisant
les indices de test, qui sont placés dans le rapport de formation.
tInd = tr.testInd;
tstOutputs = net(inputs(tInd));
tstPerform = perform(net,targets(tInd),tstOutputs)
5 Exécutez quelques analyses de la réponse de réseau. Si vous cliquez Regression dans la fenetre de
formation (training window), Vous pouvez exécuter une régression linéaire entre les productions de
réseau et les cibles correspondantes.
La figure suivante montre les résultats.
M.Helaoui
28
La production suit à la trace les bons cibles pour la formation, le test et la validation et la R-valeur est
plus de 0.95 pour la réponse totale. Si des résultats encore plus précis ont été exigés, vous pourriez
essayer n'importe laquelle de ces approches :
·Reset les poids de réseau initiaux et les préventions à nouvelles valeurs avec init et train de nouveau.
·Augmenter le nombre de neurones cachés.
· Augmenter le nombre de vecteurs de formation.
· Augmenter le nombre de valeurs d'entrés, si des informations plus appropriées sont disponibles.
·Essayez un algorithme de formation différent.
Dans notre cas, la réponse de réseau est satisfaisante et vous pouvez maintenant utiliser le réseau avec
de nouveaux entrés.
6 Considérez le diagramme de réseau.

view(net)
Cela crée le diagramme de réseau suivant.
M.Helaoui
29
Pour obtenir plus d'expérience dans des opérations de ligne de commande, essayez certaines de ces
tâches :
•Pendant la formation, ouvrez une fenêtre d’affichage (comme l’affichage de régression) et animez la
• Affichez de la ligne de commande avec les fonctions comme plotfit, plotregression, plottrainstate et
plotperform.
M.Helaoui
30
Intelligence artificielle Réseaux perceptron et règles d’apprentissage ISIMa 2011
TP3 Réseaux
perceptron et règles
d’apprentissage
Objectif
Ce TP a plusieurs objectifs. D'abord, il vous présente l'étude de règles : méthodes

d’apprentissage, qui est une procédure par laquelle un réseau est ajusté pour faire un
travail particulier.
En effet, ce TP définit que signifie une règle apprenante, explique le réseau perceptron et
son étude de la règle et vous présente comment initialiser et simuler des réseaux
perceptron. Il décrit la boîte à outils de MATLAB permettant de créer un réseau de
perceptron simple tout en présentant les fonctions pour initialiser et simuler de tels
réseaux. Le perceptron est utilisé comme un lien de ces divers concepts.
Vous pouvez créer des réseaux perceptron avec la fonction newp. Ces réseaux peuvent
être initialisés, simulés et formés avec init, sim, et train. Le modèle de Neurone décrit
comment les perceptrons travaillent tout en présentant ces fonctions.
Enfin, nous implémentons un algorithme qui exploite les règles d’apprentissage.
Modèle de Neurone
Rosenblatt [Rose61] a créé plusieurs variations de perceptrons. Un du plus simples
était un réseau d’une seule couche dont les poids W et les préventions b pourraient être
ajustés pour produire un vecteur cible correct en partant d’un vecteur d’entrés (Input) P.
Le perceptron occupe un grand intérêt en raison de sa capacité de se généraliser de ses
vecteurs de formation et apprendre en partant de connexions initialement aléatoirement
distribuées. Les perceptrons sont particulièrement convenus pour des problèmes de la
classification de modèle simples. Ils sont des réseaux rapides et fiables pour les
problèmes qu'ils peuvent résoudre. De plus, une compréhension des opérations du
perceptron fournit une bonne base pour comprendre des réseaux plus complexes.
Ci-dessous on présente un neurone : perceptron, qu'utilise la fonction de transfert

hard-limit hardlim :
M.Helaoui
31
Chaque entrée externe est pondérée avec un poids approprié W1j et la somme des
entrées pondérées est envoyée à la fonction de transfert hard-limit, qui a aussi une
entrée de 1 transmise par le déplacement (la prévention) b. Ci-dessous on présente la
fonction de transfert hard-limit, qui rend 0 ou 1 :
Le neurone perceptron retourne 1 si l’entrée du réseau dans la fonction de

transfert est supérieure ou égal à 0; sinon il retourne 0.
La fonction de transfert hard-limit donne à un perceptron la capacité de classifier des

vecteurs d'entrées en divisant l'espace d'entrées dans deux régions. Spécifiquement, les
productions (Outputs) seront 0 si l’entrée au réseau n est inférieur à 0, ou 1 si l’entré au
réseau n est supérieur ou égale à 0.
La figure suivante montre l'espace d’entrées d'un neurone hard-limit à deux entrées avec
les poids W11 =-1, W12=1 et un déplacement b=0.
M.Helaoui
32
Deux régions de classification sont formées par la frontière de décision L : Wp+b=0. Cette
ligne est perpendiculaire à la matrice de poids W et changée selon le déplacement b. Les
vecteurs d'entrés ci-dessus et à gauche de la ligne L aboutiront à un réseau d’entrées
plus grand que 0 et, donc, causent une production de 1 au neurone de hard-limit. Les
vecteurs d'entrés ci-dessous et à droite de la ligne L causent une production de 0 au
neurone.
Les neurones de hard-limit sans un déplacement (b=0) auront toujours une ligne de
classification passant l'origine. L'ajout d'un déplacement b permet au neurone de
résoudre des problèmes où les deux ensembles de vecteurs d'entrées ne sont pas placés
sur les côtés différents de l'origine. Le déplacement permet à la frontière de décision
d'être changée loin de l'origine, comme indiqué dans la figure ci-dessus.
TAF
1. Créer un fichier Neurone.m
2. Exécuter le programme nnd4db de démonstration. Avec cela déplacer une
frontière de décision autour, choisir de nouveaux entrées pour classifier et voir
comment l'application répétée de la règle apprenante rapporte un réseau qui
classifie vraiment les vecteurs d'entrées correctement.
3. Trouver trois combinaisons {W,b} permettant de classifier l’espace d’entrées
comme désiré sachant que P= [p1=5, p2=1]. Dans chaque proposition trouver
respectivement la valeur entière minimale respectivement de W11 W12 et b.
Travailler sous forme de commentaires.
4. Représenter ces trois solutions dans une même figure (Utiliser un subplot pour
chaque solution, les trois subplots doivent occuper le même espace. Dans chaque
subplot représenter la droite de départ L et la droite solution Lsi avec une autre
couleur, n’oublier pas de tracer W et Wsi).
5. Proposer et implémenter un algorithme (sous forme de fonction nommée
classification) qui en faisant varier progressivement W11 W12 et b permet de
classifier l’espace d’entrées comme désiré. L’algorithme partira des valeurs de
M.Helaoui
33
W11 W12 et b très faible, choisis par l’utilisateur, il calcule a, il affiche la décision
courante, par la suite, il permet à l’utilisateur de choisir le poids ou le
déplacement qui sera incrémenté d’une unité selon son désir. L’algorithme doit
s’arrêter lorsque a=1. Et il doit afficher W, b et la décision.
6. Implémenter un second algorithme (sous forme de fonction nommée
classification_opt) qui en faisant varier un seul paramètre choisit par l’utilisateur
retourne la valeur optimale de ce paramètre pour laquelle a=1.
Architecture
Le réseau perceptron est formé d’une seule couche : il s’agit de S perceptrons de
neurones connectés aux R entrées par un un ensemble de poids
Wij, comme indiqué ci-dessous en deux formes. Comme auparavant, les indices de réseau
i et j indiquent que Wij est la force de la connexion du jème entrée au ième neurone.
Le perceptron qu’on va étudier est capable de former seulement une seule couche. Ainsi
on considère des réseaux à une seule couche ici. Ce qui nous présente des limites au
perceptron.
Création d’un perceptron : TAF
1. Dans un fichier Creation_perceptron.m créer un perceptron avec la fonction newp:
• net = newp(P,T)
Les paramètres d’entrées sont comme suit:
M.Helaoui
34
• P est une matrice R-par-Q tel que Q représente les vecteurs d’entrées et R ses
éléments.
• T est une matrice S-par-Q tel que Q représente les vecteurs cible (target) et S ses
éléments.
La fonction hardlim est utilisée souvent par défaut pour les perceptrons.
Les commandes suivantes permettent de créer un réseau de perceptron avec un seul

vecteur d’entré P qui prend les values 0 et 2, et un neuron avec un vecteur de sortie
(outputs) T qui prend les valeurs 0 ou 1:
• P = [0 2];
• T = [0 1];
• net = newp(P,T);
2. Vérifier que le réseau a été créé en exécutant la commande suivante:
• inputweights = net.inputweights{1,1}
•
ce qui produit:
• inputweights =
• delays: 0
• initFcn: 'initzero'
• learn: 1
• learnFcn: 'learnp'
• learnParam: []
• size: [1 1]
• userdata: [1x1 struct]
• weightFcn: 'dotprod'
• weightParam: [1x1 struct]
•
La fonction d’apprentissage par défaut est learnp. Le net d’entrée de la fonction de

transfert hardlim est dotprod, Ce qui génère la production du vecteur d’entré P et la
matrice des poids W et ajoute b pour calculer le net d’entrée.
La fonction d’initialisation par défaut est initzero et elle est utilisée pour initialiser les
valeurs des poids à 0.
3. Similairement taper
• biases = net.biases{1}
•
donne
• biases =
• initFcn: 'initzero'
• learn: 1
M.Helaoui
35
• learnFcn: 'learnp'
• learnParam: []
• size: 1
• userdata: [1x1 struct]
•
4. Vérifier que b est aussi initialisé à 0.
Simulation (sim)
Cette sous section montre comment la fonction sim tourne en utilisant un

problème simple.
Supposons que nous traitons un seul perceptron (netex) avec 2 vecteurs P1 et P2

d’entrées chacun avec 2 éléments P1=[-2 2] et P2=[-2 2]. Ce perceptron a comme sorties
les valeurs 0 et 1.
TAF
1. Créer ce perceptron en utilisant le fichier exemple_sim.m

2. Quelles sont les valeurs initiales des poids et du déplacement b.
3. Nous voulons des poids et un déplacement avec des valeurs différentes de celles
d’initialisation pour cela mettez les deux poids et le déplacement à -1, 1 et 1, en
utilisant les commandes suivantes :
• net.IW{1,1}= [-1 1];

• net.b{1} = [1];
4. Afficher les valeurs de ces paramètres par les commandes suivantes:
• net.IW{1,1}
• ans =
• -1 1
• net.b{1}
• ans =
• 1
•
5. Maintenant voir si le réseau répond à deux signaux, un sur chaque côté de la

frontière du perceptron :
• p1 = [1;1];
• a1 = sim(net,p1)
• a1 =
• 1
•
Et pour
• p2 = [1;-1];
M.Helaoui
36
• a2 =
• 0
•
6. S’assurer que le perceptron a classifié les deux entrées correctement.

7. Présenter les deux entrées en ordre et obtenir tous les productions comme suit :
• p3 = {[1;1] [1;-1]};
• a3 =
• [1] [0]
•
Initialization (init) : TAF
1. Utiliser la fonction init pour remettre W et b à leurs valeurs originales.

Supposons, par exemple, que vous commencez par le réseau utiliser un fichier
nommé exemple_Init.m
• net = newp([-2 2;-2 2],[0 1]);

•
2. Afficher les valeurs de W et b

3. Affecter les valeurs 3 et 4 à W et la valeur 5 à b
4. Afficher W et b
5. Utiliser la fonction init pour remettere W et b à leurs valeurs d’origine:
• net = init(net);
•
6. Afficher les nouvelles valeurs de W et b

7. Changer l’effet de la fonction init. Par exemple nous allons faire de sorte que la
fonction init affecte des valeurs aléatoires à W et b à travers les fonctions
initFcns et rands:
• net.inputweights{1,1}.initFcn = 'rands';
• net.biases{1}.initFcn = 'rands';
• net = init(net);
•
8. Afficher les nouvelles valeurs de W et b
Régles d’aprentissage
Une règle d’apprentissage est définie comme une procédure pour modifier W et b d'un
réseau. (Cette procédure peut aussi être mentionnée comme un algorithme recevant une
formation.) la règle apprenante est appliquée pour apprendre au réseau à exécuter une
certaine tâche particulière. L'étude de règles dans ce tp traite deux larges catégories :
étude surveillée et étude non surveillée.
M.Helaoui
37
Dans l'étude surveillée, on fournit à la règle apprenante un ensemble d'exemples

(ensemble de formation) de comportement de réseau approprié
{P1, T1}, {P2,T2},..,{PQ,TQ}
Où PQ est l’ensemble des entrées au réseau et TQ est la correspondante correcte

production (cible). Comme les entrées sont appliquées au réseau, les productions de
réseau sont comparées aux cibles. La règle apprenante est alors utilisée pour ajuster W
et b du réseau pour ajuster les productions de réseau vers les cibles. Les règles
d’apprentissage du perceptron assurent l’apprentissage de cette catégorie.
Dans l'étude non surveillée, W et b sont modifiés en réponse seulement des entrées au
réseau. Il n'y a aucune production cible disponible. La plupart de ces algorithmes
exécutent des opérations pendantes par grappes. Ils catégorisent les modèles d'entrées
dans un nombre fini de classes. C'est particulièrement utile dans de telles applications
que la quantification vectorielle.
Règles d’apprentissage du perceptron
Les perceptrons sont formés et appliqués sur les exemples de comportement

désirable. Le comportement désirable peut être récapitulé par un ensemble d'entrés Pi,
des paires de production Ti. Où P est l’ensemble des entrées au réseau et T est la
correspondante correcte production (cible). L'objectif est de réduire l'erreur e, qui est la
différence T-a entre la réponse de neurone a et le vecteur cible T. La règle
d’apprentissage du perceptron learnp calcule des changements désirables à W et b du
perceptron, étant donné un vecteur d'entrées P et l'erreur associée e. Le vecteur cible T
doit contenir les valeurs de 0 ou 1, parce que un perceptron (avec des fonctions de
transfert de hardlim) peut seulement assurer la production de ces valeurs.
Chaque fois la fonction learnp est exécutée, le perceptron aura une meilleure chance
d’obtenir des productions correctes. La règle d’apprentissage du perceptron est prouvée
pour converger vers une solution dans un nombre fini d'itérations si une telle solution
existe.
Si b n'est pas utilisé, learnp cherche à trouver une solution en variant seulement W pour
classifier les vecteurs d'entrées comme 1 et loin de les classifier comme 0. Cela aboutit à
une frontière de décision qui est perpendiculaire à W et qui classifie correctement les
vecteurs d’entrées.
Il y a trois conditions qui peuvent arriver pour un neurone simple une fois qu'un vecteur
d'entrée P est présenté et la réponse du réseau a est calculée :
1er CAS. Si un vecteur d'entrée P est présenté et la production du neurone est correcte (a
= T et e = T - a = 0), donc le vecteur de poids W ne sera pas changé.
2ème CAS. Si la production de neurone est 0 et devrait être 1 (a = 0 et T = 1 et e = T - a =

1), le vecteur d'entrée P sera ajouté au vecteur de poids W. Cela fait que le vecteur de
poids W pointe plus près du vecteur d’entré, en augmentant ainsi la chance que le
vecteur d'entrée sera classifié comme 1 dans l'avenir.
M.Helaoui
38
3ème CAS. Si la production de neurone est 1 et devrait être 0 (a = 1 et T = 0 et e = T - a =-

1), le vecteur d’entrées P est soustrait du vecteur de poids W. Cela fait que le vecteur de
poids pointe plus loin du vecteur d’entrées, en augmentant la chance que le vecteur
d'entrées sera classifié comme 0 dans l'avenir.
La règle d’apprentissage du perceptron peut être écrite en termes de l'erreur e = T - a et

le changement doit être fait au vecteur de poids deltat W :
CASE 1. Si (e = 0) alors faire
DeltatW = 0.
CASE 2. Si (e = 1) alors
DeltatW = PT.
CASE 3. If (e = -1) alors
DeltatW = -PT.
Ces trois cas peuvent être résumés par cette expression:
Deltat W=(T-a) PT =ePT
Vous pouvez obtenir l'expression pour des changements de b d'un neurone en notant que
b est simplement un poids qui a toujours des entrées de 1 :
Deltat b=(T-a) (1) =e
Pour le cas d'une couche de neurones vous avez
Deltat W=(T-a) (P)T =e(P)T
Et Deltat b=(T-a) (1) =e
TAF
1. Dans un fichier RAP.m commencer avec un neurone simple ayant un

vecteur d'entrées avec juste deux éléments. Voici des vecteurs d'entrées
avec les valeurs -2 et 2 et des productions avec des valeurs 0 et 1 : créer le
perceptron netRAP.
2. Pour simplifier, prendre b = 0 et des valeurs de W de 1 et -0.8:
3. Soit une paire d’entrées production (target) donnée comme suit
• p = [1; 2];
• t = [1];
4. Calculer la production a et l’erreur e.

5. Utiliser la fonction learnp pour calculer la variation de poids dw.
M.Helaoui
39
• dw = learnp(w,p,[],[],[],[],e,[],[],[])
• dw =
• 1 2
6. Calculer les nouveaux poids.

7. Essayer la démonstration nnd4pr. Il vous permet de choisir des nouveaux
vecteurs d'entrées et appliquer la règle apprenante pour les classifier.
8. Le processus de trouver de nouveaux poids W (et des déplacements b) peut
être répété jusqu'à il n'y a aucune erreur. Rappelez-vous que le perceptron
garantit que la règle d’apprentissage converge dans un nombre fini
d'étapes pour tous les problèmes qui peuvent être résolus par un
perceptron. Ceux-ci incluent tous les problèmes de classification qui sont
linéairement séparables. Les objets à être classifiés dans de tels cas
peuvent être séparés par une ligne simple. Implémenter un algorithme de
classification qui exploite les règles d’apprentissage du perceptron.
Implémenter toutes les fonctions utilisées.
M.Helaoui
40
Troisième partie :
La logique floue
M.Helaoui
41
Intelligence artificielle Utiliser un régulateur avec Matlab ISIMa 2011
TP4 Utiliser un
régulateur avec
Matlab
Exemple 0 Application avec Matlab
Principe
Le calcul en logique floue nécessite, outre la licence de base MATLAB, l'achat et
l'installation du Fuzzy Control Toolbox. Celui-ci met à disposition de l'utilisateur deux
outils fondamentaux:
Un guide de construction du régulateur par logique floue.
Un bloc fonctionnel à intégrer dans un schéma de régulation Simulink.
Conception du régulateur
On accède à la fenêtre principale du «FIS Editor» par une instruction sur la ligne de
commande MATLAB: » fuzzy
Fig. 1 Fenêtre principale de l'éditeur de logique floue.
M.Helaoui
42
On y choisit premièrement le nombre d'entrées depuis la barre de menu: Edit --> Add
input. On trouve alors sur la fenêtre principale du «FIS Editor» autant d'icônes qu'on
veutde signaux d'entrées et sorties, et une pour les règles d'inférence. La partie
inférieure permette de spécifier les méthodes d'inférences. On accède alors à une
fenêtre spécifique par un double clics sur l'icône du signal dont on veut spécifier les
fonctions d'appartenance.
Fig. 2 Fenêtre de l'éditeur de fonctions d'appartenance d'un signal.
On doit y accomplir les actions suivantes, de préférence dans l'ordre indiqué:

Choix de la gamme de variation de chaque signal, de préférence [–1; 1], ce qui implique
que
les signaux soient d'abord normalisés.
Choix des fonctions d'appartenance depuis la barre de menu: Edit → Add MFs... . On
accède alors à une fenêtre qui permet de choisir le nombre de fonctions et leur type. On
préférera les formes simples – triangle «trimf» et trapèze «trapmf» – peu coûteuses en
temps et en espace mémoire.
Sur la fenêtre MF, on choisit le nom et la dimension de chaque fonction
d'appartenance: soit
en déplaçant les points du graphique avec la souris, soit en spécifiant le vecteur dans la
fenêtre «params». Pour le nom, un mnémonique – tel EZ pour "environ zéro" – vaut
mieux que mf1 à mfn attribués par défaut. On ferme ensuite chaque fenêtre de signal.
De retour dans le du «FIS Editor», on choisit le nom du signal de préférence à inputk
attribué par défaut.
M.Helaoui
43
Fig. 3 Fenêtre de l'éditeur de fonctions d'appartenance d'un signal: exemple.
Lorsque tous les signaux sont spécifiés, on ouvre l'éditeur des règles d'inférence:
Fig. 4 Fenêtre de l'éditeur de règles d'inférence.
On termine en définissant les méthodes pour interpréter les combinaisons logiques et

les règles d'inférence. On recommande ici des choix qui ne soient pas trop gourmands
en temps de calcul, en donnant des résultats assez bons. Pour le ET logique (And
method), on choisit la méthode produit (prod) et pour le OU logique (Or method), on
choisit la méthode Maximum (max).
Pour les règles d'inférence, on préfère la méthode somme-produit: Implication: prod et
Agrégation: mean. Pour la défuzzyfication, on recommande la méthode du centre de
gravité (centroid).
On ferme toutes les fenêtres secondaires de l'éditeur FIS avant d'enregistrer le
régulateur sur le disque en choisissant un nom dont on se souviendra facilement. Si on
veut ensuite utiliser ce régulateur dans un schéma Simulink, il faut encore l'enregistre
dans l'espace de travail MATLAB: Workspace.
M.Helaoui
44
Essai en simulation
On crée un schéma Simulink dans lequel on colle un bloc "Fuzzy Logic Controller"
qu'on trouve dans la boîte "SIMULINK Fuzzy", elle-même placée dans la boîte
"Blocksets & Toolboxes". On doit y spécifier un nom de régulateur parmi ceux chargés
précédemment dans l'espace de travail. Ce bloc doit être précédé de blocs gain chargés
de la normalisation des signaux et suivi d'un gain ajustable de l'amplification du
régulateur.
Exemple 1 Contrôle du niveau d'eau
(http://www.tn.refer.org/hebergement/cours/logique_floue/_we_hinfo/trav1.htm)
On peut construire le régulateur (contrôle du niveau de l’eau) à l’aide des interfaces

graphiques proposées par la Fuzzy Logic Toolbox ; pour y accéder on tapera fuzzy à
partir de l’environnement MATLAB; Le Fis Editor apparaît et nous permet alors
d’accéder aux autres interfaces, on procède alors comme suit :
Avec le Fis Editor On a définit les entrées; Le niveau Level et sa dérivé rate; On
définit ensuite la sortie commande de la valve: valve, en choisissant les options add
input et add output du menu Edit.
Le menu view permet de passer d’une interface graphique à une autre. On définit
ensuite les ensembles flous et les fonctions d’appartenances de l’entrée level en
utilisant l’option add mfs du menu édit. On précisera alors le type de ces fonctions :
gaussiènnes et l’intervalle sur le quel varie cette entrée.
M.Helaoui
45
On fait de même pour l’entrée variation de niveau: rate et on s’intéressera aux petites
variations.
On définit ensuite les fonctions d’appartenances de la sortie valve selon la commande

qu’on désire.
M.Helaoui
46
Sur le Rule Editor on définit les règles d’inférences liants les entrées et la sortie du
régulateur. On définit à chaque fois la relation logique entre les deux entrées, ensuite
on choisit la sortie qu’on va appliquer et on clique sur add rule.
Une fois les entrées sont définies, ainsi que la sortie et les règles, on enregistre notre
système d’inférence (le régulateur flou crée) dans le workspace sous le nom tank.fis.
Lors de la construction du modèle du système sur SIMULINK on utilisera le bloc Fuzzy
Controller pour modéliser le régulateur flou. Et en cliquant sur ce bloc, on nous invite à
préciser quel système d'inférences on va utiliser, On choisira alors le tank.fis. Une fois
la simulation est lancée on peut voir la réponse du système sur le scope1. Les interfaces
Rule Viewer et Surface Viewer s’activent avec la simulation.
Le rule viewer qui s’active pendant la simulation nous permet de voir la participation
M.Helaoui
47
de chaque règle dans la commande ; il fera ensuite la moyenne pour déduire la

commande valve.
Le graphique de la fonction : Valve = f(level, rate) est donné par la Surface Viewer, si
on remarque bien il y a une asymétrie sur ce graphe ; elle est dûe à l’asymétrie de la
sortie valve.
TAF :
1. Copier le dossier fuzzy de la toolbox vers votre répertoire de travail.
M.Helaoui
48
2. A partir de fuzzy.m, créer fuzzy_water.m avec des données conformes à l’exemple 1.
M.Helaoui
49
Intelligence artificielle Exemple de freinage ISIMa 2011
TP5 Exemple de
Freinage
M.Helaoui
50
M.Helaoui
51
M.Helaoui
52
M.Helaoui
53
TAF
Questions
1. Définire la logique floue et son utilité.

2. Comparer une variable binaire et une variable Floue.
3. Différences entre théorie de probabilité, thèorie de possibilité et la logique
floue ?
4. Historique de la logique floue ?
5. Les ensembles flous : apports et utilités.
6. Comment la notion de degré d’apportenance a été introduite ?
7. Décrire les différentes composantes d’un controleur flou ?
8. Etudier le Problème controleur flou de freinage.
9. Créer fuzzy_freinage.m avec des données conformes à ce problème.
M.Helaoui
54
Intelligence artificielle Références de base ISIMa 2011
Références de base
1. Ben Krose., Patrick. van. der. Smagt. An introduction to Neural Networks, Eighth
edition November, 1996.
2. Cornelius T. Leondes, Fuzzy Logic and Expert Systems Applications, by

ACADEMIC PRESS 1998.
3. Equipe du Laboratoire Analyse et Commande des Systèmes

(LACS- Tunisie) avec le soutien de l'Agence Universitaire de la
Francophonie,
http://www.tn.refer.org/hebergement/cours/logique_floue/index.html#
4. Gérard Dreyfus. Neural Networks Methodology and Applications, Springer-

Verlag Berlin Heidelberg 2005.
5. La toolbox Réseaux de neurones de Mathlab
6. Valluru B. Rao. C++ Neural Networks and Fuzzy Logic, IDG Books Worldwide,
Inc., 1995.
M.Helaoui
55
View publication stats

TPs Intelligence Artificielle ISIMa 2011

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TPs Intelligence Artificielle ISIMa 2011

Transféré par

Droits d'auteur :

Formats disponibles

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

Travaux Pratiques : Intelligence Artiﬁcielle

Book · July 2011

How Machine can take decision? View project

Extended Shortest Path Problem View project

The user has requested enhancement of the downloaded file.

Enseignant : Maher Helaoui

Maher Helaoui a enseigné comme assistant contractuel à l’Institut Supérieur

Il est aussi chercheur en Intelligence Artificielle, au Pôle de Recherche en

TP1 Initiation Matlab

Qu'est ce que Matlab ?

A propos des versions

Matlab comme interpréteur en ligne

Pour obtenir une liste des fonctions matricielles élémentaires taper :

realmax plus grand nombre en virgule flottante :

Un peu plus sur les matrices

On utilise souvent des matrices de grandes dimensions (résultats de mesures par

Ctrl-C Ctrl-V, M-files, fonctions : rationalisons notre travail

Copier-Coller (Ctrl-C Ctrl-V)

function Maxi = Moyenne(Note_2009, Note_2008)

2. Créer les données suivant :

La commande >> Najah

La commande >> Raceb

Instructions et structures de contrôle

Il est parfois possible de réduire le temps de calcul en utilisant la vectorisation.

Un peu plus sur la programmation

Tracer des courbes et créer une figure

Style et couleurs des lignes

Superposer des courbes

Ajouter des courbes à une figure existante

Plusieurs courbes dans une même fenêtre

La figure créée est reproduite ci-après :

Placer des titres et des commentaires

Un peu plus sur les graphiques

Présentation des réseaux de neurones

TAF : Exemple Illustrative de Classification des fruits

- Il est possible d’utiliser d’autres techniques : dans la command window tapez:

- Dans la command window tapez:

- Quelle est la nouvelle technique de classification utilisée ?

Pour définir un problème à la boîte à outils, arrangeons un ensemble de vecteurs

La sous section suivante démontre comment apprendre à un réseau d’adapter un ensemble de

Utilisation de l'Outil d'Ajustement de Réseau de Neurone

1 Ouvrir l’outil d’ajustement en tapant:

2 Cliquer Next pour procéder.

9 Cliquer Régression. Ceci est utilisé pour valider la performance de réseau.

10 Considérez l'histogramme d'erreur pour obtenir une vérification supplémentaire de la performance

Comment utiliser la fonctionalité de la ligne de commande

La façon la plus facile d'apprendre comment utiliser la fonctionnalité de ligne de commande

% Solve an Input-Output Fitting problem with a Neural Network

% Set up Division of Data for Training, Validation, Testing

3 Formez le réseau. Le réseau utilise par défaut l’algorthme de Levenberg-Marquardt pour la

6 Considérez le diagramme de réseau.

Ce TP a plusieurs objectifs. D'abord, il vous présente l'étude de règles : méthodes

Enfin, nous implémentons un algorithme qui exploite les règles d’apprentissage.

Ci-dessous on présente un neurone : perceptron, qu'utilise la fonction de transfert

Le neurone perceptron retourne 1 si l’entrée du réseau dans la fonction de

La fonction de transfert hard-limit donne à un perceptron la capacité de classifier des

Création d’un perceptron : TAF

1. Dans un fichier Creation_perceptron.m créer un perceptron avec la fonction newp:

Les paramètres d’entrées sont comme suit:

Les commandes suivantes permettent de créer un réseau de perceptron avec un seul

2. Vérifier que le réseau a été créé en exécutant la commande suivante:

La fonction d’apprentissage par défaut est learnp. Le net d’entrée de la fonction de