Aller au contenu


Information tutoriel

  • Ajouté le: mai 31 2008 04:19
  • Date Updated: juil. 06 2011 03:41
  • Lectures: 23786
 


* * * * *
0 Notes

Les réseaux de neurones

Posté par delfare-RX on mai 31 2008 04:19

Leur but

Un réseau de neurones est une approche inspirée du système nerveux humain. Les problèmes que peut traiter efficacement ce réseau sont aujourd'hui mieux définis : vision, reconnaissance de la parole et des formes, robotique, planifications... .

Toutes ces tâches qui paraissent si simples à l'esprit humain, en fait, sont en fait très complexes, voir impossible, pour un ordinateur.

Leurs exigences au niveau des connaissances

Le développement des systèmes de neurones est pluridisciplinaire c'est-à-dire qu'il demande des connaissances dans différents domaines :
Des chercheurs de formations mathématiques et physiques qui apportent leurs outils pour modéliser le système nerveux. Des chercheurs issus de milieu biologique, neurophysiologique ou médical fournissent leurs connaissances du système nerveux aux ingénieurs, informaticiens, des électroniciens... .

Cette étude des réseaux de neurones réunit outre des médecins et spécialistes, des neurosciences, des chimistes, des psychologues, des mathématiciens, des spécialistes de l'optique et des télécommunications.

Les méthodes d'investigation

Actuellement, la plupart des recherches sont effectuée sur des logicielles de simulations de réseaux de neurones ce qui permet d'expérimenter un grand nombre de lois de fonctionnement de ces réseaux sans nécessiter de gros investissements matériels. Ces simulations demandent des ordinateurs classiques éventuellement dopés par des coprocesseurs pour accélérer les temps de calculs (Par exemples les neurocomputers : circuits électroniques ou optiques qui fonctionnent massivement en parallèles). En effet l'une des caractéristiques de ces systèmes est qu'ils nécessitent un grand nombre de calculs (vectoriels et matriciels), d'autant plus long que le nombre de neurones du réseau est important.

Fonctionnement d'un réseau de neurones

Il existe différents types de réseaux de neurones : statiques, dynamiques, en couche et en rétroaction.

Le fonctionnement des systèmes de neurones, à l'instar du système nerveux biologique, se caractérise par trois principes :

  • le parallélisme des opérations de traitement
  • le caractère collectif et la distribution de l'activité des éléments du réseau
  • les capacités d'apprentissage à partir d'exemple

Les simulations des systèmes de neurones ont manifesté des comportements analogues à ceux du modèle vivant : mémoire à long terme et à court terme. On a même observé l’existence d'une limite du nombre d'article enregistrable en une seule fois ; si cette limite est dépassée, des objets de la mémoire sont effacés : c'est ce que l'on appelle l'effet " PALIMPSESTE ".

On pourrait penser que plus le nombre de neurones est important, plus le réseau est performant. Ceci n'est pas certains. Lorsque les concepteurs des réseaux essayent d'augmenter le nombre de neurones, ils sont limités par plusieurs contraintes, et en particulier par la durée d'apprentissage qui augmente avec le nombre de neurones. En effet, l'apprentissage s'effectue par l'exemple et il faut que le nombre de ceux-ci soit bien plus important que le nombre de connexions. Quand on sait qu'un système de 1000 neurones possède plus de 1000 000 connexions, on peut craindre le temps d'apprentissage.

Intelligence artificielle (IA) et Réseaux de neurones (RN)

La démarche des réseaux de neurones s'oppose à celle de l'intelligence artificielle. Cette dernière est fondée sur l'utilisation de règles qui sont manipulées selon les techniques de la logique formelle. Celle-ci fournit une représentation explicite du raisonnement (par exemple le raisonnement de l'expert dans les systèmes experts), en vue de la résolution d'un problème particulier. L'intelligence artificielle implique une approche "descendante" partant de l'analyse de la manière dont l'être humain procède pour résoudre des problèmes ou pour les apprendre et tente de restituer cette démarche en la décomposant en unités élémentaires.

Les réseaux de neurones impliquent une approche "ascendante" qui tente de produire des phénomènes complexes comme l'apprentissage ou reconnaissance de forme à partir d'opérations très élémentaires.

Le perceptron Théorie



Dans ce tuto, je vais essayer d'expliquer le fonctionnement des réseaux de neurones pour faire de l'intelligence artificielle (reconnaissance de formes, etc).

Pour essayer de ne pas rendre ce tuto trop compliqué à comprendre, je vais me baser sur un exemple : la reconnaissance de caractères.

Chaque pixel de l'image est un neurone et ils sont tous reliés aux 7 neurones : les 7 chiffres qu'on lui apprend.
Chaque liaison entre les neurones et le chiffres ont un poids.
Un chiffre est reconnu si la somme des données qui lui sont envoyées ( multiplication de l'entrée du neurone (pixel de l'image) et du poids (qui peut être négatif) ) est positif.

Tout d'abord, nous allons produire 7 caractères :
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,

1,1,1,1,1,
0,0,0,0,1,
0,0,0,0,1,
1,1,1,1,1,
1,0,0,0,0,
1,1,1,1,1,

1,1,1,1,1,
0,0,0,0,1,
0,0,0,0,1,
1,1,1,1,1,
0,0,0,0,1,
1,1,1,1,1,

1,0,1,0,1,
1,0,1,0,0,
1,0,1,0,0,
1,1,1,1,1,
0,0,1,0,0,
0,0,1,0,0,

1,1,1,1,1,
1,0,0,0,0,
1,1,1,1,1,
0,0,0,0,1,
0,0,0,0,1,
1,1,1,1,1,

1,1,1,1,1,
1,0,0,0,0,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,

1,1,1,1,1,
0,0,0,0,1,
0,0,1,1,1,
0,0,0,0,1,
0,0,0,0,1,
0,0,0,0,1,

Ce sont les 7 premiers chiffres.

Nous allons donc créer un tableau de poids de 7*30 (30, car les images des chiffres font 7*5 pixels)

Nous allons ensuite l'initialiser entre -50 et 50, aléatoirement.

Calcul pour tester un chiffre

On initialise la variable totale à zéro.
Pour tout pixel activé de l'image :
total = total + poids du neurone correspondant(lié au chiffre et au numéro du pixel)

Si total > 0, alors le chiffre est reconnu.

Apprendre une forme

Pour tous les chiffres à tester, faire le calcul de test du chiffre et stocker le résultat dans une variable.
Pour tous les pixels de l'image :
poids correspondant = poids + (valeur à obtenir - valeur obtenue) * valeur du pixel * 10

"valeur à obtenir" est 1 ou 0 : quand on veut apprendre le chiffre, on lui donne l'image et la valeur. (si la valeur est égale au chiffre qu'on teste, alors "valeur à obtenir" est égale à 1
"valeur obtenue" est le résultat du calcul de test du chiffre.
"valeur du pixel" est 1 ou 0 (si le pixel est noir ou blanc).

Si la valeur à obtenir est égale à la valeur obtenue, alors "valeur à obtenir - valeur obtenue" s'annule et donc le poids reste le même.

Si le pixel n'est pas allumé, le poids n'est pas changé(puisqu'il n'est pas pris en compte dans le calcul)
Si la valeur à obtenir est égale à 1 et si la valeur obtenue est égale à 0, alors "valeur à obtenir - valeur obtenue" égale 1 et donc le poids augmente.
Si la valeur à obtenir égale 0 et la valeur obtenue est égale à 1, alors "valeur à obtenir - valeur obtenue" égale -1 et donc le poids diminue.

L'apprentissage doit être refait plusieurs fois jusqu'à ce que la reconnaissance des chiffres soit correcte.

Source :
Isib.be : la page n'existant plus, voici un extrait :

Règle d'apprentissage de windrow-Hoff :

W3,1=0.03+0.1(1-0)1=0.13

Avec:

0.03= 3 divisé par 100 car les valeurs dans la matrice ont été préalablement multipliées par 100.

0.1= h.

1= Tj= valeur désirée en sortie.

0= Oj= valeur de la sortie.

1= Xi= valeur de l'entrée.

Les autres connexions de la sortie 1 sontrespectivement 0.06, 0.31 ,-0.03,0.09 et -0.12 pour les entrées8,13,18,23,28.

 

Après une itération, le nombre d'erreur tombeà 11. Il faut 25 itérations au perceptron pour apprendreparfaitement. Si h est égale à 0.9, cinq itérations seraientsuffisantes au lieu de 25.

 

La matrice de résultat devient maintenant lamatrice identité.

 

1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 1

L'intensité correcte des connexions estdonnée par la matrice suivante :

-28 -35 8 -2 23 -32 -18 -7 -67 -55
-17 27 -59 -22 -63 -28 -1 -31 23 25
13 -51 5 -28 -10 1 6 -64 -75 4
-17 23 16 29 -33 -45 28 -18 5 5
-43 23 38 -33 4 17 -22 -46 -23 -14
-33 -41 -50 31 -24 50 -10 42 112 49
-21 -23 -41 55 -43 0 -12 -22 41 3
6 24 -45 26 17 13 -37 -48 9 27
13 24 13 40 9 -37 -19 -35 -19 -1
35 1 44 -23 -18 -46 -13 -11 -12 5
7 40 -47 -7 10 36 5 -15 39 12
14 -14 11 31 -47 -61 -33 10 31 -97
31 44 14 -32 -38 -1 5 25 48 -71
-31 20 -5 9 -5 -21 36 46 -15 -12
-9 -26 16 -25 -11 -54 36 -27 -10 22
13 3 -45 2 50 -35 -22 79 -110 -37
20 -7 -46 45 11 3 29 -71 -54 -83
-3 -45 -56 8 -24 -5 -15 -19 -7 -45
-48 18 21 -35 26 27 -9 -40 -8 -24
-4 -25 13 -26 12 19 10 39 25 25
-21 44 -49 -40 -49 28 28 94 -37 57
2 30 21 34 -48 39 2 -4 -43 21
-11 -3 18 -20 32 17 39 4 -46 -15
29 -28 -15 -18 -29 28 -6 -23 11 -23
-49 -20 -25 13 22 -40 -60 37 23 -18
-8 28 18 -39 44 11 13 -61 -42 26
13 -19 -29 -52 -1 35 25 -31 -23 19
-12 18 28 -18 -22 -61 -69 -51 38 -36
12 -26 -10 10 -22 23 -54 29 -24 -27
-40 -18 3 0 9 0 5 -23 -7 -54


Le perceptron - Programmation


Ici, je vais expliquer comment coder un perceptron qui reconnaît 7 caractères graphiques.
Prérequis pour comprendre ce tuto :

Savoir programmer en C.
Avoir compris le tuto précédent.

D'abord, on va initialiser les 7 caractères à reconnaitre :

Code : C
int numeros[7][30]=
{
{
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
}
,
{
1,1,1,1,1,
0,0,0,0,1,
0,0,0,0,1,
1,1,1,1,1,
1,0,0,0,0,
1,1,1,1,1,
}
,
{
1,1,1,1,1,
0,0,0,0,1,
0,0,0,0,1,
1,1,1,1,1,
0,0,0,0,1,
1,1,1,1,1,
}
,
{
1,0,1,0,1,
1,0,1,0,0,
1,0,1,0,0,
1,1,1,1,1,
0,0,1,0,0,
0,0,1,0,0,
}
,
{
1,1,1,1,1,
1,0,0,0,0,
1,1,1,1,1,
0,0,0,0,1,
0,0,0,0,1,
1,1,1,1,1,
}
,
{
1,1,1,1,1,
1,0,0,0,0,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
}
,
{
1,1,1,1,1,
0,0,0,0,1,
0,0,1,1,1,
0,0,0,0,1,
0,0,0,0,1,
0,0,0,0,1,
}
};

Ensuite, on va initialiser un tableau des poids :

Code : C
float poids[7][30];

Une fonction pour initialiser les poids (aléatoirement entre -50.0 et 50.0) :

Code : C
int init()
{
    int i,j;
    for(j=0;j<7;j++)
    {
       for(i=0;i<30;i++)
          poids[j]<italique>=(float)(rand()%100-50);
    }
}

La fonction de calcul :

Code : C
int calcul(int num, int num2)
{
    int i;
    float total=0;
    for(i=0;i<30;i++)
    {
       if(numeros[num]<italique>==1)
       {
          total+=poids[num2]<italique>;
       }  
    }
return total>0?1:0;
}

La fonction pour modifier les poids :
Code : C
float calcule_poids(float valeur,int valeur_desiree,int valeur_obtenue,int valeur_entree)
{
    float result = (valeur+(valeur_desiree-valeur_obtenue)*valeur_entree*10.0);
    return result;
}

La fonction d'apprentissage(num est le caractère graphique et num2 est le poids à lier. Si num = num2, le calcul doit sortir 1).

Code : C
int apprendre(int num, int num2)
{
int i;
int result=calcul(num,num2);
for(i=0;i<30;i++)
{
   poids[num2]<italique> = calcule_poids((float)poids[num2]<italique>,num==num2,result, numeros[num]<italique>);
}
return 1;
}

Et enfin, la fonction main :

Code : C
int main(int argc, char *argv[])
{
  //initialise les poids
  init();
  int i,j;
  while(1)
  {
  /*quand ça affiche la matrice d'identité, c'est que les données sont apprises correctement*/
  for(j=0;j<7;j++)
  {
     for(i=0;i<7;i++)
     {
        printf("t%d",calcul(i,j));
     }
  printf("n");
  }
  /*on fait relier tous les poids avec tous les caractères*/
  for(j=0;j<7;j++)
  {
     for(i=0;i<7;i++)
        apprendre(i,j);
  }  
  printf("nn");
  system("pause");
}
  return 0;
}