Apprentissage, Réseaux de neurones et Modèles graphiques (RCP209)

Le Perceptron Multicouches

Charger la Toolbox Netlab

- Créer un répertoire Netlab
- Lancer firefox
- Adresse de la Toolbox Netlab
http://www1.aston.ac.uk/eas/research/groups/ncrg/resources/netlab/downloads/
- Cliquer sur Downloads
- Charger dans le répertoire Netlab le fichier netlab3 3.tar en cliquant sur :
”gzip file” de la Toolbox 3.3 (Date : 18/06/2004)
- Charger aussi dans le répertoire Netlab le fichier foptions.m
- décompresser le fichier netlab3 3.tar → tar xvf netlab3 3.tar puis rm netlab3 3.tar
- Vous disposez alors de la toolbox Netlab dans le répertoire Netlab.

Fonctions importantes de Netlab pour un perceptron multicouches

• Net = mlp(nin, nhidden, nout,outfunc);
Elle permet de définir une architecture et d’initialiser les poids.
. nin : nombre de neurones en entrée.
. nhidden : nombre de neurones cachés.
. nout : nombre de neurones en sortie.
. outfunc : fonction d’activation pour la couche de sortie (= ’linear’, ’logistic’ ou ’softmax’)
→ help mlp pour plus de détails.
• [Net, options] = netopt(Net, options, x, t, alg);
alg = ’scg’ ,’conjgrad’ ou ’quasinew’ (algorithme d’optimisation)
→ help netopt pour plus de détails..
• Ycal = mlpfwd(Net, X); % sortie calculée par le réseau Net pour l’entrée X.

Données simulées.
Ecrire les commandes suivantes dans un fichier script donnees.m
n=300; X=4*(rand(n,1)-.5); X=sort(X);
a=2; b=5; Y=a*X + b; Yb=Y+.2*randn(size(Y,1),1);
plot(X,Y,’b-’,X,Yb,’r.’)
save data1 X Y Yb
Y=zeros(size(X)); Y=Y+sin(pi*X).*((X>-1) & (X<1)); Yb=Y+.2*randn(size(Y,1),1);
figure
plot(X,Y,’b-’,X,Yb,’r.’)
save data2 X Y Yb
Placez-vous dans la fenêtre de commande Matlab et tapez : donnees
 2

Utilisation d’un perceptron sans couche cachée

Ecrire les commandes suivantes dans un fichier script test1.m
addpath Netlab
load data1;
pas=10;
Xapp=X(1:pas:length(X));
Yapp=Yb(1:pas:length(Yb));
ne = size(Xapp,2);
ns = size(Yapp,2);
Net = glm(ne, ns, ’linear’);
options = foptions;
options(1) = 1; % affichage des erreurs
options(2) = 0.001; % précision sur la variation des poids
options(3) = 0.001; % précision sur la variation de l’erreur
options(14)=100; % nombre de cycles d’apprentissage
options(18)=0.01; % pas d’apprentissage
[Net1 options errlog pointlog]= netopt(Net, options, Xapp, Yapp,’graddesc’);
subplot(3,1,1)
plot(errlog);
subplot(3,1,2)
plot(pointlog);
Ycalculee=glmfwd(Net1,X);
subplot(3,1,3)
plot(X,Y,’b-’,X,Yb,’g.’,X,Ycalculee,’r-’)
Placez-vous dans la fenêtre de commande Matlab et tapez : test1
- Comparer Net1.w1 avec le coefficient directeur a et Net1.b1 avec l’ordonné à l’origine b
- Faire varier le pas d’apprentissage
- Faire varier le nombre de cycles d’apprentissage
- Remplacer la fonction netopt par la fonction oldg
[Net1 options errlog pointlog]= olgd(Net, options, Xapp, Yapp);
- Remplacer la fonction netopt par la fonction glmtrain
[Net options] = glmtrain(Net, options, Xapp, Yapp);
Ycalculee=glmfwd(Net,X); plot(X,Y,’b-’,X,Yb,’g.’,X,Ycalculee,’r-’)
- Utiliser data2 à la place de data1
Copier le script demglm1.m de la toolbox Netlab dans un fichier demo1.m et le script demglm2.m
dans un fichier demo2.m
- Tester demo1.m et demo2.m
- Faire varier les paramètres d’apprentissage dans demo1.m et demo2.m

Utilisation d’un perceptron multicouches

Ecrire les commandes suivantes dans un fichier script test2.m (copier test1.m dans test2.m puis
modifier test2.m).
load data2;
pas=10; Xapp=X(1:pas:length(X)); Yapp=Yb(1:pas:length(Yb));
ne = size(Xapp,2); ns = size(Yapp,2); nc=3;
 3

Net = mlp(ne, nc, ns, ’linear’);

options=zeros(1,18); options(1)=1; options(2)=0.0001; options(3)=0.0001;
options(14)=1000;
options(18)=0.01;
algorithm = ’graddesc’;
[Net1 options errlog pointlog] = netopt(Net, options, Xapp, Yapp, algorithm);
subplot(3,1,1)
plot(errlog);
subplot(3,1,2)
plot(pointlog);
Ycalculee=mlpfwd(Net1,X);
subplot(3,1,3)
plot(X,Y,’b-’,Xapp,Yapp,’g.’,X,Ycalculee,’r-’)
Placez-vous dans la fenêtre de commande Matlab et tapez : test2
- Faire varier le pas d’apprentissage
- Faire varier le nombre de cycles d’apprentissage
- Tester le weight decay :
alpha = 0.2;
Net = mlp(ne, nc, ns, ’linear’,alpha);
- Tester le momentum : options(17)=0.5;
- Tester les autres algorithmes d’apprentisage : ’conjgrad’, ’scg’ et ’quasinew’
Charger le fichier MlpLearn.m dans le répertoire Netlab.
Ecrire les commandes suivantes dans un fichier script Apprend.m
global options
addpath Netlab
load data2
% Base d’apprentissage et base de test
% Un point sur trois pour l’apprentissage et le reste pour le test
I=1:3:length(X);J=1:length(X);J=setdiff(J,I);
Xapp=X(I); Yapp=Yb(I); Xtest=X(J); Ytest=Yb(J);
NbreNeurEntree = size(Xapp,2);
NbreNeurSortie = size(Yapp,2);
NbreNeurCache = 5;
Net = mlp(NbreNeurEntree, NbreNeurCache, NbreNeurSortie, ’linear’);
SeuilArret = 0.0001;
algorithm = ’scg’;
NbreIterations=1000;
NbreIterAvantTest=10;
figure
set(gca,’YScale’,’log’)
[Net, ErrAppr, ErrTest, CurIter, Yac, Ytc] = MlpLearn ( ...
Net, Xapp, Yapp, Xtest, Ytest, ...
NbreIterations, NbreIterAvantTest, SeuilArret, algorithm);
figure
Ycalculee=mlpfwd(Net,X);
plot(X,Y,’b-’,X,Ycalculee,’r-’)
legend(’: Y désiré’,’: Y calculé’);
 4

Placez-vous dans la fenêtre de commande Matlab et tapez la commande Apprend

Vous pouvez faire d’autres apprentissages en modifiant les différents paramètres influant sur
l’apprentissage dans les scripts Apprend.m et MlpLearn.m

Problème réel de classification : les Iris de Fisher

Les Iris de Fisher correspondent à 150 fleurs décrites par 4 variables quantitatives : longueur
du sépale, largeur du sépale, longueur du pétal et largeur du pétal.
Les 150 fleurs sont réparties en 3 différentes espèces : iris setosa, iris versicolor et iris virginica
Chaque classe est composée de 50 fleurs. La classe setosa est linéairement séparable des deux
autres, alors que versicolor et virginica ne le sont pas.
Le fichier iris don.mat contient les vecteurs d’entrée en dimension 4 décrivant les 150 iris. Le
fichier iris cls.mat contient les classes des 150 iris. Pour lire ces fichiers faire :
load -ascii iris don.mat
load -ascii iris cls.mat
Le codage classique des sorties désirées pour la classification utilise un neurone de sortie par
classe, avec une valeur désirée haute pour le neurone de la classe correcte, et une valeur désirée
faible pour les autres classes. Nous allons utiliser le codage suivant :
classe 1 → (1 0 0) classe 2 → (0 1 0) classe 3 → (0 0 1)
Vous pouvez générer la matrice de sortie en utilisant les instructions Matlab suivantes :
>> iris output=zeros(150,3);
>> iris output(find(iris cls==1),1)=1;
>> iris output(find(iris cls==2),2)=1 ;
>> iris output(find(iris cls==3),3)=1;
Apprentissage
- Utiliser 100 Iris pour l’apprentissage et les autres pour le test.
- Utiliser 3 neurones cachés.
- Pour un problème de classification, il vaut mieux utiliser des fonctions d’activation
non linéaires à la couche de sortie. Utiliser la fonction ’softmax’.
- Faire 100 cycles d’apprentissage
- évaluer l’erreur de classification au moyen de la matrice de confusion et identifier
les instances mal classées. Vous pouvez utiliser les instructions Matlab suivantes :
>> Ycalculee=mlpfwd(Net,iris input);
>> classe t=iris cls;
>> [max y classe y]=max(Ycalculee’);
>> classe y=classe y’;
>> exemples mal classes=find(classe t∼=classe y);
>> NetClass=zeros(150,3);
>> NetClass(find(classe y==1),1)=1;
>> NetClass(find(classe y==2),2)=1;
>> NetClass(find(classe y==3),3)=1;
>> conffig(NetClass,iris output)
- Faire varier les paramètres d’apprentissage.

Le problème des taches solaires (”sunspot” ) : sélection de variables

Il s’agit du nombre moyen annuel de taches noires observées sur le soleil entre 1700 et 1979
(280 points). La série des taches solaires est très courte et célèbre dont l’équation sous jacente
 5

est inconue. La figure 1 montre l’évolution annuelle de cette série.

0.9

0.8

0.7
Average sunspot activity

0.6

0.5

0.4

0.3

0.2

0.1

0
1700 1750 1800 1850 1900 1950 2000
Year

Figure 1: série sunspot normalisée de 1700 à 1979.

Pour ce problème, on essaie de prédire une valeur en utilisant les 12 valeurs précédentes. Il faut
donc utiliser un réseau avec une couche d’entrée de 12 neurones et une couche de sortie de 1
neurone

Données d’apprentissage et de validation

On utilise les données de 1712 à 1920 pour l’apprentissage (un ensemble DApp de 209 exemples),
et les données de 1921 à 1955 pour la validation (un ensemble DV al de 35 exemples). Pour le
test, on utilise les données de 1956 à 1979 (un ensemble DT est de 24 exemples).

Mesure de qualité
Les performances du modèle sont calculées en utilisant le critère ARV (”Average Relative
Variance”), qui est le rapport entre l’erreur quadratique moyenne du moèle et la variance des
données. La définition de l’ARV établit un rapport entre l’erreur du modèle et la variance des
données calculée sur le même ensemble D (pris de l’ensemble entier S).
∑
(y i − f (xi ))2
i∈D
arv(D) = ∑ (1)
(y i − µD )2
i∈D

où y i est la valeur de la série à l’instant i, f (xi ) est la sortie du réseau à l’instant i, et µD la
moyenne de la valeur désirée dans D.

Cependant, la définition de l’ARV la plus utilisée utilise la variance totale des données (de
la série). ∑
1
|D|
(y i − f (xi ))2
i∈D
arv(D) = ∑ (2)
1
|S|
(y i − µS )2
i∈S
i i
où y est la valeur de la série à l’instant i, f (x ) est la sortie du réseau à l’instant i, et µS la
moyenne de la valeur désirée dans S (la série entière) .
Afin de comparer votre ARV avec celles obtenues en utilisant d’autres méthodes, utiliser la
formule (2).
 6

• Constituer les ensembles DApp , DV al et DT est :

– DApp (ensemble d’apprentissage) : il sert à calculer les poids du réseau.
– DV al (ensemble de validation) : il sert à éviter le sur-apprentissage (à déterminer
quand arrêter l’apprentissage).
– DT est (ensemble de test) : il sert à évaluer les performances du résau obtenu. Cet
ensemble ne doit pas intervenir ni pour la détermination des poids ni pour l’arrêt de
l’apprentissage.
• Apprentissage
– Utiliser un réseau avec une couche cachée.
– Utiliser la méthode HVS pour sélectionner les variables pertinentes.

Utilisation dun MLP pour la classification de Chiffres Manuscrits : choix du codage

L’objectif de cette partie est de comparer les performances d’un classifieur MLP en fonction des
différents types de codage que l’on va faire sur les chiffres, et qui serviront d’entrée au réseau
de neurones.
Les Données : la base de donnée de chiffres manuscrits est composé de 480 chiffres manuscrits
codés en binaire (±1), dans une matrice 256x480. Chaque bitmap binaire 16x16 a été trans-
formée en un vecteur de dimension 256 qui, à son tour, correspond à une colonne de la matrice
x, stockée dans le fichier x.mat.
Base d’apprentissage, base de validation et base de test
on va diviser cette base de données en 3 parties :
- Un ensemble d’apprentissage (de 1 300) qui sert à calculer les poids du réseau
- Un ensemble de validation (de 301 400) qui sert vérifier quil n’y a pas de sur-apprentissage.
- Un ensemble de test (de 401 480) qui sert à évaluer les performances du réseau obtenu.
Codage des données. Soient :
- HX : histogramme des projections du chiffre sur l’axe des x (dans chaque colonne on
compte le nombre de pixels noir). HX est donc un vecteur de 16 composantes.
- HY : histogramme des projections du chiffre sur l’axe des y (dans chaque ligne on compte
le nombre de pixels noir). HY est aussi un vecteur de 16 composantes.
- PH : profil haut pour chaque colonne, on code la coordonnée de la première transition
blanc/noir en partant du haut. PH est un vecteur de 16 composantes.
- PB : profil bas pour chaque colonne, on code la coordonnée de la première transition
blanc/noir en partant du bas. PB est un vecteur de 16 composantes.
- PG: profil gauche pour chaque ligne, on code la coordonnée de la première transition
blanc/noir en partant de la gauche. PG est un vecteur de 16 composantes.
- PD: profil droit pour chaque ligne, on code la coordonnée de la première transition
blanc/noir en partant de la droite. PD est un vecteur de 16 composantes.
Les 6 cas de codage à essayer sont:
1. entrée (HX,HY), vecteur de 32 composantes.
2. entrée (PG,PD), vecteur de 32 composantes.
3. entrée (HX,HY,PG,PD), vecteur de 64 composantes.
4. entrée (PB,PH), vecteur de 32 composantes.
5. entrée (HX,HY,PB,PH), vecteur de 64 composantes.
6. entrée image sous forme d’un vecteur de 256 pixels. Fichier x.mat.
Comparez ces codages en termes de performances sur la base de test.