SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE …antoine.soubigou.org/pdfensais/Projet Neuromimetique.pdf · La réponse du réseau est lue directement sur les unités de sortie

SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE GUENNOU Pascal

Professeur : M. JP. Urban

Projet neuromimétique M. JP. Urban


Introduction …………………………………………………1 I Exercice 1 …………………………………………………..2 I.1. Le programme.……………………………………………………………………2 I.2. La fonction inverse……………………………………………………………….4 I.3. La fonction logarithme…………………………………………………...………5 I.4. La fonction exponentielle………………………………………………….……..6 I.5. La fonction sinus ………………………………………………………...……….6 II Exercice 2……………………………………………..…..8 Conclusion ………………………………………….………10 Index des figures …..……………………………….………11 Annexes ….…………………………………….……………12

1. La fonction inverse……………………………………………..………………..13 2. La fonction logarithme…………………………………………………………..13 3. La fonction exponentielle………………………………………….…………….14 4. La fonction sinus…………………………………………………..……………..14 5. Programme exercice 2……………………………………………..…………….15 6. Les différentes fonctions d’apprentissage………………………..…………….16

Projet neuromimétique M. JP. Urban - 1 -

SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE GUENNOU Pascal Introduction

Un réseau de neurones est un outil d’analyse statistique permettant de construire un modèle de comportement à partir de données qui sont des exemples de ce comportement. Un réseau de neurones est constitué d’un graphe pondéré orienté dont les nœuds symbolisent les neurones. Ces neurones possèdent une fonction d’activation qui permet d’influencer les autres neurones du réseau. Les connexions entre les neurones, que l’on nomme liens synaptiques, propagent l’activité des neurones avec une pondération caractéristique de la connexion. On appelle poids synaptique la pondération des liens synaptiques.

Notre projet a pour but ici de mettre en place des programmes de réseaux de neurones sous Matlab, qui utilise la rétropropagation du gradient pour identifier différentes courbes.

Les neurones peuvent être organisés de différentes manières, c’est ce qui définit

l’architecture et le modèle du réseau. L’architecture la plus courante est celle dite du perceptron multicouche (utilisée dans nos exercices). Avant de pouvoir utiliser les capacités de classification d’un réseau de neurones, il faut le construire. Ceci se déroule en quatre temps:

1. La construction de la structure du réseau (généralement empirique). 2. La constitution d’une base de données de vecteurs représentant au mieux le domaine

à modéliser. Celle-ci est scindée en deux parties : une partie servant à l’apprentissage du réseau (on parle de base d’apprentissage) et une autre partie aux tests de cet apprentissage (on parle de base de test).

3. Le paramétrage du réseau par apprentissage. Au cours de l’apprentissage, les vecteurs de données de la base d’apprentissage sont présentés séquentiellement et plusieurs fois au réseau. Un algorithme d’apprentissage ajuste le poids du réseau afin que les vecteurs soient correctement appris. L’apprentissage se termine lorsque l’algorithme atteint un état stable.

4. La phase de reconnaissance qui consiste à présenter au réseau chacun des vecteurs de la base de test. La sortie correspondante est calculée en propageant les vecteurs à travers le réseau. La réponse du réseau est lue directement sur les unités de sortie et comparée à la réponse attendue. Une fois que le réseau présente des performances acceptables, il peut être utilisé pour répondre au besoin qui a été à l’origine de sa construction. En annexe 6 le premier tableau représente les différents algorithmes que l’on peut utiliser pour l’apprentissage. La figure suivante nous précise clairement que c’est l’algorithme de Levenberg-Marquardt qui montre les meilleurs résultats, c’est pourquoi on l’utilisera dans nos exercices.


SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE GUENNOU Pascal I Exercice 1 Le but de cet exercice est de mettre en place un réseau de neurones utilisant la rétropropagation du gradient, afin d’élaborer un programme d’identification de courbes. Les cinq courbes sont les suivantes :

)(sin)( xcxf =2

1 π≤≤ x

x

xf 1)( = 1001 ≤≤ x

)(log)( 10 xxf = 101 ≤≤ x )exp()( xxf −= 101 ≤≤ x

xxf sin)( =2

1 π≤≤ x

Une consigne dans ce problème est d’utiliser qu’une seule couche cachée de neurones. L’intérêt sera ensuite de jouer sur le nombre de neurones cachés et d’en déduire leur influence. Nous allons d’abord voir la structure de la base du programme. I.1. Le programme et fonction sinus cardinale

)(sin)( xcxf =

% approximation de fonction avec l'algorithme de rétropropagation 1. n=10; % fonction de difficulté grandissante 2. k=70; % impose le nombre de données d'entrée 3. P = -2:(.4/k):2; T = sinc(n*P); 4. close all, figure(1),plot(P,T,'.b'),hold on 5. pause 6. netsin=newff(minmax(P),[50,1],{'logsig','purelin'},'trainlm'); 7. netsin.trainParam.epochs=1000; 8. netsin.trainParam.goal=1e-5; 9. [netsin,tr]=train(netsin,P,T); 10. p=-2:0.01:2; a=sim(netsin,p); figure(1),plot(p,a,'r')

On initialise donc dans un premier temps la fonction à apprendre. Il s’agit ici de la fonction sinus cardinale. Aux lignes 1 et 2, on met en place deux variables n et k qui vont


SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE GUENNOU Pascal servir respectivement à faire varier la période de la fonction et à changer le nombre de points qui la compose.

A la ligne 3 on crée la fonction modèle. Ensuite on crée un objet réseau de neurone. A la ligne 6, on met en place avec la

fonction newff un réseau composé de 1 couche cachée de 50 neurones et une couche de sortie de 1 neurone. La fonction d’activation utilisée à la sortie de la couche cachée est logsig et celle de la couche de sortie est purelin. Pour l’apprentissage, on utilisera l’algorithme de calcul de Levenberg-Marquardt : trainlm.

La ligne 7 permet de régler le nombre d’epochs c’est-à-dire le nombre de cycle d’apprentissage. La ligne 8 précise l’erreur à atteindre. La ligne suivante lance le calcul d’apprentissage par la fonction train.

Et au final on trace la courbe obtenue par le réseau (ligne 9). Voici la fonction à apprendre, le sinus cardinal :

On lance alors le programme d’apprentissage de la courbe. On observe ensuite à la

fois l’évolution de l’erreur à chaque epoch, puis la fonction obtenue par le réseau :

A première vu, le résultat parait tout à fait satisfaisant. La courbe suit bien tous les points. Cependant en effectuant un zoom sur la première partie de la courbe, on observe un décalage évident.



Pour améliorer l’apprentissage et pour obtenir une courbe plus proche du modèle, on joue alors sur différents paramètres tel le nombre de neurones de la couche cachée. Par exemple, en doublant son nombre le résultat donne ceci :

Le résultat obtenu avec les nouveaux paramètres d’apprentissage est tout à fait satisfaisant.

I.2. La fonction inverse Le programme est en annexe 1.

xxf 1)( =



On remarque que pour cette courbe, un nombre de neurone faible est suffisant pour la couche cachée. En effet, la courbe a une décroissance régulière, elle est moins « complexe » que la fonction sinus cardinal. Le réseau a alors plus de facilité pour l’identifier. I.3. La fonction logarithme Le programme est en annexe 2.

)(log)( 10 xxf =


SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE GUENNOU Pascal Idem que la fonction inverse, l’apprentissage se fait très facilement, même avec un nombre de neurone faible.

I.4. La fonction exponentielle Le programme est en annexe 3.

)exp()( xxf −=

Pour cet exemple, l’apprentissage est excellent. Avec des petits paramètres (nombre limité de neurones dans la couche cachée), nous obtenons de très bon résultats : écart d’erreur quasi nulle (environ 10-14).


SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE GUENNOU Pascal I.5. La fonction sinus Le programme est en annexe 4.

. xxf sin)( =

Là aussi on obtient de très bons résultats. L’identification est parfaite avec très peu de neurones. Ce résultat provient peut-être de la régularité des oscillations. Si on effectue un essai avec seulement 10 neurones et très peu de points pour le modèle (20 points pour une période), le résultat est surprenant :


SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE GUENNOU Pascal II Exercice 2 Cet exercice a pour but d’utiliser l’algorithme de rétropropagation pour déterminer un modèle mathématique représentatif de l’évolution des données.

Pour ce faire, un tableau de valeur nous est fourni. Les informations concernent l’âge et le poids de l’acuité visuelle des lapins sauvages d’Australie. Ces informations sont non linéaires, l’objectif de cet exercice est donc d’observer le comportement d’un réseau de neurone lorsqu’on travail avec un domaine non linéaire. Voici les données du problème :

Ages Weights Ages Weights Ages Weights Ages Weights(days) (mg) (days) (mg) (days) (mg) (days) (mg)15 21,66 75 94,6 218 174,18 338 203,2315 22,75 82 92,5 218 173,03 347 188,3815 22,3 85 105 219 173,54 354 189,718 31,25 91 101,7 224 178,86 357 195,3128 44,79 91 102,9 225 177,68 375 202,6329 40,55 97 110 227 173,73 394 224,8237 50,25 98 104,3 232 159,98 513 203,337 46,88 125 134,9 232 161,29 535 209,744 52,03 142 130,68 237 187,07 554 233,950 63,47 142 140,58 246 176,13 591 234,750 61,13 147 155,3 258 183,4 648 244,360 80 147 152,2 276 186,26 660 23161 73,09 150 144,5 285 189,66 705 242,464 79,09 159 142,15 300 186,09 723 230,7765 79,51 165 139,81 301 186,7 756 242,5765 65,31 183 153,22 305 186,8 768 232,1272 71,9 192 145,72 312 195,1 860 246,775 86,1 195 161,1 317 216,41

Weights of Eyes Lenses of Wild Australian Rabbits

Figure 1 : Tableau de données de l’exercice 2

Dans un premier temps, on trace ces données et on les compare avec un modèle non linéaire obtenu par la méthode des moindres carrés utilisant une exponentielle négative :

ε+•−−•= ))006042.0exp(1(846.233 xy

Figure 2 : Comparaison du modèle non linéaire (rouge) et des données (bleu)



Nous avons maintenant utilisé le programme de rétropropagation utilisée dans l’exercice précédent. Cependant, on a dû agir sur l’ensemble des paramètres pour optimiser l’apprentissage de la courbe afin d’obtenir une courbe la plus proche possible du modèle.

Figure 3 : Résultat du programme

En bleu on a les données du tableau, en vert la fonction exponentielle donnée, et en rouge le résultat du réseau de neurones. Nous avons eu du mal à obtenir un résultat satisfaisant. Après avoir testé les différents algorithmes de calcul, l’algorithme de Levenberg-Marquardt semble être le plus rapide et le plus précis pour le travail demandé ici. On observe donc que dans ce genre de problème, les réseaux de neurones ne sont pas vraiment performants. Comparé à l’exercice 1, où les fonctions sont continues et régulières, ici les points sont peu nombreux (notamment entre 394 et 513 pour l’âge où la variation du poids est importante) et la variation entre eux est parfois très grande. Nous remarquons aussi que, lorsque les variations de données sont régulières, le réseau de neurone travaille correctement, par contre, quand ces données sont irrégulières le réseau diverge.


SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE GUENNOU Pascal Conclusion

Le grand avantage des réseaux de neurones réside dans leur capacité d’apprentissage automatique, ce qui permet de résoudre des problèmes sans nécessiter l’écriture de règles complexes, tout en étant tolérant aux erreurs. Cependant, ceux sont de véritables boites noires qui ne permettent pas d’interpréter les modèles construits. En cas, d’erreurs du système, il est quasiment impossible d’en déterminer la cause. Ces deux exercices nous ont permis de mettre en application le cours sur les réseaux de neurones de M. Urban. Nous avons pu ainsi voir leur utilité au niveau de la reconnaissance de signaux. On peut alors imaginer l’éventail des possibilités d’utilisation de ces réseaux dans tous les domaines (commande de bras de robots, acquisition de scènes en 3D grâce à un robot binoculaire, la médecine etc.….).



Figure 1 : Tableau de données de l’exercice 2 ............................................................................8 Figure 2 : Comparaison du modèle non linéaire (rouge) et des données (bleu) ......................8 Figure 3 : Résultat du programme ..............................................................................................9





Annexe 1 : La fonction inverse

% approximation de fonction avec l'algorithme backpropagation % 19/01/03 % initialisation de la fonction à apprendre clear for k=1:100 P(1,k)=k; T(1,k)=1/k; end close all,figure(1),plot(P,T,'.b'),hold on pause % création d'un objet réseau de neurone net=newff(minmax(P),[30,1],{'logsig','purelin'},'trainlm'); net.trainParam.epochs=1000 net.trainParam.goal=1e-5 %net.trainParam.lr_inc=1.1 %net.trainParam.lr=0.05 [net,tr]=train(net,P,T); % simulation du réseau pour vérifier la capacité de généralisation p=1:1:100; a=sim(net,p); figure(1),plot(p,a,'r')

Annexe 2 : La fonction logarithme

% approximation de fonction avec l'algorithme backpropagation % 19/01/03 % initialisation de la fonction à apprendre k=1; % impose le nombre de données d'entrée P = 0.2:(.1/k):10; T = log(P); close all,figure(1),plot(P,T,'.b'),hold on pause % création d'un objet réseau de neurone net=newff(minmax(P),[20,1],{'logsig','purelin'},'trainlm'); net.trainParam.epochs=200 net.trainParam.goal=1e-5 %net.trainParam.lr_inc=2 %net.trainParam.lr=0.5 [net,tr]=train(net,P,T); % simulation du réseau pour vérifier la capacité de généralisation p=0.1:0.05:10; a=sim(net,p); figure(1),plot(p,a,'r')



Annexe 3 : La fonction exponentielle

% approximation de fonction avec l'algorithme backpropagation % 19/01/03 clear; % initialisation de la fonction à apprendre k=0.01; % impose le nombre de données d'entrée P = 0:(.001/k):10; T = exp(-P); close all,figure(1),plot(P,T,'.b'),hold on pause % création d'un objet réseau de neurone net=newff(minmax(P),[30,1],{'logsig','purelin'},'trainlm'); net.trainParam.epochs=1000 net.trainParam.goal=1e-20 %net.trainParam.lr_inc=1.1 %net.trainParam.lr=0.05 [net,tr]=train(net,P,T); % simulation du réseau pour vérifier la capacité de généralisation p=0:0.05:10; a=sim(net,p); figure(1),plot(p,a,'r')

Annexe 4 : La fonction sinus

% approximation de fonction avec l'algorithme backpropagation % 19/01/03 % initialisation de la fonction à apprendre n=10; % fonction de difficulté grandissante k=10; % impose le nombre de données d'entrée P = -2:(.4/k):2; T = sin(n*P); close all,figure(1),plot(P,T,'.b'),hold on pause % création d'un objet réseau de neurone net=newff(minmax(P),[10,1],{'logsig','purelin'},'trainlm'); net.trainParam.epochs=1000; net.trainParam.goal=1e-5; [netsin,tr]=train(net,P,T); % simulation du réseau pour vérifier la capacité de généralisation p=-2:0.01:2; a=sim(net,p); figure(1),plot(p,a,'r')



Annexe 5 : Programme exercice 2 clear all; hold on; x = 1:1:860; % Création des matrices ages et weigths ages=[15 18 28 29 37 44 50 60 61 64 65 72 75 75 82 85 91 97 98 125 142 147 150 159 165 183 192 195 218 219 224 225 227 232 237 246 258 276 285 300 301 305 312 317 338 347 354 357 375 394 513 535 554 591 648 660 705 723 756 768 860]; weigths=[22.23 31.25 44.79 40.55 48.56 52.03 62.3 81 73.09 79.09 71.41 71.9 86.1 94.6 92.5 105 102.3 110 104.3 134.9 135.63 153.75 144.5 142.15 139.81 153.22 145.72 161.1 173.605 173.54 178.86 177.68 173.73 160.635 187.07 176.13 183.4 186.26 189.66 186.09 186.7 186.8 195.1 216.41 203.23 188.38 189.7 195.31 202.63 224.82 203.3 209.7 233.9 234.7 244.3 231 242.4 230.77 242.57 232.12 246.7]; % On trace la courbe avec les valeurs du tableaux et celle en rouge est l'approximation. figure(1) plot(ages,weigths) plot(x,233.846*(1-exp(-.006042*x)),'r') pause % création d'un objet réseau de neurone net=newff(minmax(ages),[80,1],{'logsig','purelin'},'trainlm'); % net.trainParam.lr_inc=1.1 net.trainParam.lr=1; % net.trainParam.show=50; net.trainParam.epochs=300; net.trainParam.goal=1e-2; [net,tr]=train(net,ages,weigths); % simulation du réseau pour vérifier la capacité de généralisation p=1:1:860; a=sim(net,p); figure(1),plot(p,a,'r'),plot(x,233.846*(1-exp(-.006042*x)),'g')




Annexe 6 : Les différentes fonctions d’apprentissage

Documents

SOUBIGOU Antoine DEA – Mulhouse Janvier 2003 LE …antoine.soubigou.org/pdfensais/Projet Neuromimetique.pdf · La réponse du réseau est lue directement sur les unités de sortie