Sie sind auf Seite 1von 18

Erik PERNOD

Calcul Scientifique
3me Anne

RESEAUX
DE
NEURONES

TABLE DES MATIERES

TABLE DES MATIERES ..................................................................................... 2


I PERCEPTRON SIMPLE ................................................................................. 3
I.1 Introduction .................................................................................................................... 3
I.2 Algorithme ...................................................................................................................... 3
I.3 Rsultats ......................................................................................................................... 4
1er exemple : ................................................................................................................................... 5
2me exemple ................................................................................................................................ 5
3me exemple ................................................................................................................................ 6

I.4 - Conclusion ....................................................................................................................... 7

II PERCEPTRON PARALLELE .......................................................................... 8


II.1 Introduction ................................................................................................................... 8
II.2 Algorithme ..................................................................................................................... 9
II.3 Rsultats ........................................................................................................................ 9
1er exemple : ................................................................................................................................. 10
2me exemple .............................................................................................................................. 11
3me exemple .............................................................................................................................. 11

.............................................................................................................................................. 12
II.4 - Conclusion .................................................................................................................... 12

III PERCEPTRON MULTICOUCHE ..................................................................13


III.1 Introduction ................................................................................................................ 13
III.2 Algorithme .................................................................................................................. 13
III.3 Rsultats ..................................................................................................................... 17
1er exemple : ................................................................................................................................. 17
2me exemple .............................................................................................................................. 17
3me exemple .............................................................................................................................. 17

III.4 - Conclusion ................................................................................................................... 18

I PERCEPTRON SIMPLE
I.1 Introduction
Le perceptron est lun des rseaux de neurones les plus utiliss pour des problmes
dapproximation, de classification et de prdiction. Dans un premier temps nous allons
tudier le perceptron simple, puis un cas de perceptron multicouche avec une couche de
deux perceptrons en parallles.
Puis pour finir nous tudierons le perceptron multicouche de taille (3x3). Dans les
trois cas, le perceptron sera assimil une classe c++ comportant ses propres lments. Une
classe Vecteur est galement utilise. Elle permet entre autre lgalit directe de deux
vecteurs, laffichage direct dun vecteur.

Perceptron simple :

Composition :
- Deux entres (dans notre cas, des coordonnes x et y dun point)
- Un biais b, assimilable une troisime entr, mais variable.
- Un systme de trois poids lies ces entrs sachant que le 3me poids correspond
au biais et est toujours gal -1.
- Une fonction de transfert (ici nous utiliserons la fonction seuil)
- Une seule sortie
Sachant que la fonction de transfert utilis est une fonction seuil, les sorties possibles de ce
perceptron sont 1 ou -1. Il ne peut donc faire que de la classification, puis de la prdiction.
On se donne un nombre N de points. Certains valant 1 et dautres -1. Nous allons tudier
comment le perceptron simple permet de sparer ces deux groupes. Si ces deux groupes
sont bien distincts, sinon nous verrons que ce type de perceptron est vite limit.

I.2 Algorithme
Initialisation des donnes :
- Nbr = Nombre de points
3

Variables : utilisation de vecteurs de float pour les coordonnes des


points, leur affinit (1 ou -1) et les poids du perceptron.
Initialisation du biais du perceptron 0.
Utilisation de fichier pour imprimer les donnes.

Insertion des points pour la phase dapprentissage :


- On insre les coordonnes de chaque point et son affinit dans 3 vecteurs
(X, Y, F). Ainsi le triplet [X(1),Y(1),F(1)] dfini le 1er point.
- Par soucis de simplicit, les poids du perceptron auront comme valeur
initiale laffinit du 1er point.
Phase dapprentissage (Pour chaque point i ) :
- Calcul de la somme : S = xi .w1 + yi .w2 1.b
- Calcul de f(S) o f est la fonction seuil.
- On compare le rsultat obtenu celui voulu (vecteur F)
- Si le rsultat est identique, on ne change pas les poids. Sil est diffrent,
on modifie les poids de la faon suivante :
w1 + xi

w1 = w1 + .( 2 ).Fi

w2 + yi

).Fi
w2 = w2 + .(
2

1 + b

b = b + .( 2 ).Fi

eta tant le coefficient dapprentissage.


-

On passe au point suivant

Critre darrt :
- A chaque itration, les poids sont modifis pour satisfaire chacun des
points. Lorsque ces poids ne sont plus modifis par aucun des points, on
arrte le programme.
- Il se peut que lensemble des points ne soient jamais satisfait par les
poids. Ce sont les cas limite que je montrerai par la suite.
Prdiction :
- Une fois les poids bien calibrs (concrtement, le domaine est spar en
deux parties, les points 1 dun cot, les -1 de lautre), il est possible de
rentrer les coordonnes dun point pour connatre son affinit.

I.3 Rsultats
Les coordonnes des points ainsi que leur affinit seront enregistr dans un fichier
Points.dat. Les poids ainsi que la valeur de b seront quant eux enregistr itration par
itration dans un fichier Droites.dat
Les graphiques illustrant les rsultats suivant sont obtenus laide dun programme Matlab
(joint avec le programme c++)
4

Je ne montrerais que des cas simplifis avec un nombre limit de points (4 points). Sachant
que rajouter des points ne modifie pas la mthode.
Les carrs rouges indiquent les points ayant une affinit gale 1 et les ronds bleus
indiquent ceux ayant une affinit de -1.

1er exemple : paramtres : 4 points, eta =1.

Dans ce cas, on constate que le biais a t modifi trop rapidement, b/w2 (ordonne
a lorigine) est pass ds la premire itration 1. Du coup le programme narrive pas
revenir en arrire et ne sarrte plus.

2me exemple : paramtres : 4 points, eta=0.1.


On rutilise les mmes points mais cette fois ci avec un coefficient dapprentissage moins
lev :

Cette fois ci, le biais na pas t modifi trop rapidement, et la courbe a eu le temps
de tourner pour satisfaire les 4 points.
La courbe en trait plein reprsente la position des poids la dernire itration.
Rappel :
xi .w1 + yi .w2 1.b

donne :
w
b
yi = 1 xi +
w2
w2
On a bien une droite du type y=a.x+b.

3me exemple : paramtres : 5 points eta =0.1.

Dans ce cas, on constate que le dernier point rajout : (4,1,-1), ne permet pas de sparer le
domaine en deux parties distinctes. Lalgorithme ne peut donc pas converger. Il sagit l de la
limite du perceptron simple.

I.4 - Conclusion
La mthode du perceptron simple permet de classifier des lments compris dans
deux catgories diffrentes. A condition que ces deux catgories soient linairement
sparables. Par la suite il est galement possible de prdire quelle catgorie appartient un
lment.

II PERCEPTRON PARALLELE

II.1 Introduction
Nous allons prsent tudier deux perceptrons en parallle. (Non lis)
Soit, deux Perceptron simple en parallle :

Composition pour chaque perceptron :


-

Deux entres (dans notre cas, des coordonnes x et y dun point)


Un biais b, assimilable une troisime entr, mais variable.
Un systme de trois poids lies ces entrs sachant que le 3me poids correspond
au biais et est toujours gal -1.
Une fonction de transfert (ici nous utiliserons la fonction seuil)
Une seule sortie

Cette fois, chaque point de notre domaine aura deux affinits, une pour chaque
perceptron. On se donne donc un nombre N de points. Il y aura donc quatre possibilits :
(1,1); (1,-1); (-1,1) ; (-1,-1) pour chaque point. Le domaine sera donc spar par deux droites.

II.2 Algorithme
Initialisation des donnes :
- Nbr = Nombre de points
- Variables : utilisation de vecteurs de float pour les coordonnes des
points, leurs affinits (1 ou -1) et les poids des deux perceptrons.
- Initialisation des biais des perceptrons 0.
- Utilisation de fichier pour imprimer les donnes.
Insertion des points pour la phase dapprentissage :
- On insre les coordonnes de chaque point et leurs affinits dans 4
vecteurs (X, Y, F1, F2). Ainsi le quadruplet [X(1),Y(1) ,F1(1),F2(1)] dfini le
1er point.
- Par soucis de simplicit, les poids des perceptrons auront comme valeur
initiale laffinit respective du 1er point.
Phase dapprentissage (Pour chaque point i ) pour une perceptron :
- Calcul de la somme : S = xi .w1 + yi .w2 1.b
- Calcul de f(S) o f est la fonction seuil.
- On compare le rsultat obtenu celui voulu (vecteur F)
- Si le rsultat est identique, on ne change pas les poids. Sil est diffrent,
on modifie les poids de la faon suivante :
w1 + xi

w1 = w1 + .( 2 ).Fi

w2 + yi

).Fi
w2 = w2 + .(
2

1 + b

b = b + .( 2 ).Fi

eta tant le coefficient dapprentissage.


-

On passe au point suivant

Critre darrt :
- A chaque itration, les poids sont modifis pour satisfaire chacun des
points. Lorsque ces poids ne sont plus modifis par aucun des points, on
arrte le programme.
- Il se peut que lensemble des points ne soient jamais satisfait par les
poids. Ce sont les cas limite que je montrerai par la suite.
Prdiction :
- Une fois les poids bien calibrs (concrtement, le domaine est spar en
deux parties, les points 1 dun cot, les -1 de lautre), il est possible de
rentrer les coordonnes dun point pour connatre ses affinits.

II.3 Rsultats
9

Les coordonnes des points ainsi que leur affinit seront enregistr dans un fichier
Points.dat. Les poids ainsi que la valeur de b seront quant eux enregistr itration par
itration dans un fichier Droites.dat pour le 1er perceptron et dans un fichier Droites2.dat
pour le 2me.
De la mme manire, grce au programme Matlab, on obtient les figures suivantes :
Lgende pour les affinits des points :
Cercle vert o : affinit de 1 pour le 1er perceptron.
Cercle mauve o : affinit de -1 pour le 1er perceptron.
Croix verte + : affinit de 1 pour le 2me perceptron.
Croix mauve + : affinit de -1 pour le 2me perceptron.
Courbes bleus : 1er perceptron
Courbes rouges : 2me perceptron
Les courbes pleines reprsentes les poids de la dernire itration (les deux perceptrons tant
indpendant, ils nont pas le mme nombre ditration).

1er exemple : paramtres : 4 points, eta =0.1.

Lalgorithme converge lentement. La courbe bleue spare bien les cercles verts o du
cercle mauve o. Et la courbe rouge spare la croix verte + des Croix mauves +.

10

2me exemple : paramtres : 4 points, eta=0.5.


On rutilise les mmes points mais cette fois ci avec un coefficient dapprentissage
plus lev :

Lalgorithme converge plus rapidement, on constate bien que le biais est lui aussi
modifi plus rapidement. En effet, les ordonnes lorigine des courbes varient de manire
importante.

3me exemple : paramtres : 4 points eta =1.

11

On constate que le perceptron 1 converge trs rapidement (courbe bleu sparant les cercles
de couleurs). Alors que le perceptron 2 subit le phnomne de sur apprentissage et
diverge. Comme nous lavons vu prcdemment, la variation des poids est trop importante
et lalgorithme ne peut pas converger.

II.4 - Conclusion
Il sagit de deux perceptrons indpendants. Il ny a donc pas de diffrence par rapport
a la partie prcdente. Nous avons class les lments suivant deux critres : (1,1); (1,-1); (1,1) ; (-1,-1). Il faudrait donc un perceptron de plus pour faire la synthse et ainsi obtenir
trois catgories dans ce cas prcis.

12

III PERCEPTRON MULTICOUCHE

III.1 Introduction
Nous allons prsent tudier le perceptron multicouche de taille 3x3.

C'est--dire que les coordonnes des points sont rentres dans la couche 1 qui
reprsente 3 perceptrons en parallles. Cette fois ci les fonctions utilises sont des fonctions
sigmodes.
Par la suite, les sorties de la couche k sont les entrs des perceptrons de la couche
k+1. Puis, les trois sorties des perceptrons de la couche 3 sont rcupres par un dernier
perceptron ayant une fonction linaire comme fonction de transfert. Ce dernier perceptron
fourni donc la valeur finale du perceptron multicouche.

Composition pour chaque perceptron :


-

Deux entres (dans le cas de la couche 1), trois entres sinon.


Un biais b variable.
Un systme de poids lies ces entrs sachant que le dernier poids correspond
au biais et est toujours gal -1.
Une fonction de transfert (la fonction sigmode)
Une seule sortie.

Dans un premier temps nous testerons lapprentissage des poids du perceptron


multicouche pour un seul point. Puis pour un nombre N de point. Sachant que nous
connaissons la valeur dsir de ces points. (exemple : approximation dune fonction dfinie
cos(x+y)

III.2 Algorithme

13

Classe perceptron (Neurone dans le prog.) :


On dfini le perceptron comme un objet, on lui associe :
Un vecteur poids, de taille variable, un biais b et la variable som qui vaut

N
i =1

wi .x i b

On lui associe les fonctions suivantes :


float Set_LVL_UP(Vecteur <float>, int);
Permet de faire passer un vecteur de coordonnes dans le perceptron. La fonction renvoi la
valeur en sortie du perceptron. On peut choisir le type de fonction de transfert. (il faut que les
poids soient dj initialis)

void Set_Poids(Vecteur <float>);

Permet de modifier manuellement les poids. (sous forme dun vecteur de taille variable + la
valeur du biais)

float Get_Resultat(Vecteur <float>);

Permet de calculer puis de rcuprer la variable som.

float Fonction_Sig(float);

Calcul de la valeur de la fonction sigmode en un point donn.

int Fonction_Seuil(float);

Calcul de la valeur de la fonction seuil en un point donn.

Classe reseau :
Il sagit en ralit dun tableau de perceptron. (A la base de taille variable mais le codage na
t test que pour un perceptron de taille 3x3)
La classe comporte donc un tableau de taille 3x3 dobjet perceptron et un perceptron
final qui se trouve en fin du rseau.

On lui associe galement un coefficient dapprentissage, et des matrices temporaires pour


stocker les valeurs pour la rtropropagation de lerreur.
Une matrice de taille 3x3 pour les variations des poids.
14

Une matrice de taille 3x3 pour les poids de la couche k+1 lors du calcul des poids de la
couche k.
Une matrice de taille 3x3 pour stocker les valeurs des sorties de chaque perceptron du
rseau.

On lui associe les fonctions suivantes :


float Initialisation(Vecteur <float>);
Permet laide dun vecteur de coordonnes dinitialiser alatoirement tout les poids des 10
perceptrons du rseau.

void Bourrage_De_Crane(Vecteur <float>, Vecteur <float>, Vecteur <float>,


float,float);

Permet En entrant un vecteur contenant les coordonnes x, un autre les coordonnes y et un


dernier les valeurs des points voulues en sortie, ainsi que le coefficient dapprentissage et la
prcision voulue, de calibrer les poids du rseau.

float Propagation_Point(Vecteur <float>);

Permet de faire passer un point (2 coordonnes) dans le rseau et dobtenir sa valeur en


sortie.

float Fonction_DSeuil(float);

Calcul de la valeur de la fonction driv de sigmode en un point donn.

Vecteur <float> Sensibilite_Finale(float, float);

Calcul de la sensibilit du dernier perceptron final .


Vecteur <float> Sensibilite(Vecteur <float>, int, Vecteur <float>);
Calcul de la sensibilit de la couche k en fonction de la couche k+1.
void Variation_Poids_Initial(Vecteur <float>, Vecteur <float>, float);
Calcul des poids initiaux de la 1re couche prenant en entr les coordonnes des points
void Variation_Poids(Vecteur <float>, float, int);
Calcul des poids de la couche k en fonction de la sensibilit de la couche k et des sorties de la
couche k-1.

15

Algorithme :

Initialisation des donnes :


- Nbr = Nombre de points
- Variables : utilisation de vecteurs de float pour les coordonnes des points
et leur valeur voulue.
- Utilisation de fichier pour imprimer les donnes.
Initialisation du rseau :
- On insre les coordonnes dun point dans le rseau
- On donne des poids alatoire la premire couche. Puis laide des
fonctions de la classe perceptron, on calcul la sortie des perceptrons de la
couche 1. Ces sorties sont stockes dans la matrice A.
- La couche suivante rcupre ces sorties et les prend en valeur dentres.
Sachant que si la couche 1 est compos de 3 perceptrons en parallles.
Alors il y aura 3 entres par perceptron de la couche suivante. Et ainsi de
suite pour les couches suivante.
- A la dernire couche on rcupre les 3 sorties et le perceptron finale
nous renvoi une seule valeur (sachant quil est compos dune fonction de
transfert linaire).
- Tout les biais sont initialis 0.
Phase dapprentissage Pour chaque point :
- On fait passer les coordonnes de ce point dans le rseau.
- On compare le rsultat obtenu (variable a) celui voulu (vecteur D)
- On calcul lerreur commise (sensibilit) : SM=-2x(d-a)
- On calcul les sensibilit de la couche k :

Puis on met jour les poids et les biais de la couche k :

- Une fois tout les poids mis jour on passe au point suivant.
Critre darrt :
- A chaque itration, les poids des perceptrons sont modifis pour satisfaire
chacun des points. Lorsque ces poids ne sont plus modifis par aucun
des points, on arrte le programme Comparaison avec une valeur epsilon
trs faible.
Prdiction :
- Une fois les poids bien calibrs il est possible de rentrer les coordonnes
dun point pour connatre sa valeur en sortie du rseau.

16

En ralit, pour un perceptron de taille 3x3, jai du dissocier la couche initiale des
autres couches car elle ne reoit pas le mme nombre dentr que les autres.
Un autre problme est la gestion des anciens poids. En effet, lors de la
rtropropagation de lerreur, au moment o les poids de la couche k+1 sont mis jour, il
faut garder les anciennes valeurs des poids, car elles sont ncessaire au calcul de la
sensibilit de la couche k.

III.3 Rsultats
Le rseau ne convergeant pas toujours trs bien. Je nutilise pas de critre darrt
pour le moment mais une simple boucle avec un nombre ditration donne.

1er exemple : Pour un point (5,2) valant 10, eta =1


Pour une valeur de eta trop forte, lalgorithme diverge. En effet, on trouve les valeurs
suivantes :
Pour 1 itrations : 64.9
Pour 10 itrations : 410
Pour 100 itrations : 1310
En regardant de plus prs les valeurs des poids, on constate que les poids des dernires
couches explosent.

2me exemple : Mme point, eta=0.4.

Pour 1 itrations : 1.94


Pour 10 itrations : 10.0004
Pour 100 itrations : 10
3me exemple : Pour plusieurs points, eta=0.4.
On effectue un test trivial :
Y=2*X
On prend 10 valeurs de la fonction quon apprend au rseau.

Apparemment il y a une erreur dans le programme car lalgorithme semble converger


daprs laffichage de la console.
Mais Lorsque je lui demande de sortir une valeur dun point, par exemple : 1,1 il donne :
18,5 et ce pour nimporte quelle valeur de point.
17

Je nai pas eu le temps de debugger ce cas avant lchance.

III.4 - Conclusion
On constate quil ne faut pas utiliser de coefficient dapprentissage trop lev, sinon
le rseau diverge compltement. Dans notre cas, pour une valeur de eta suprieur 0.5,
lalgorithme nest pas trs stable. Cependant il ne faut pas prendre de valeur trop faible non
plus, sinon le programme ne converge presque pas. Ou alors pour un nombre ditrations
trs grand.
Lalgorithme tourne bien pour un seul point. Par la suite, ce type de programme
permettrait dapproximer une fonction complte.

18

Das könnte Ihnen auch gefallen