Perceptron

Un article de Wikipédia, l'encyclopédie libre.

Cet article est une ébauche concernant l?informatique.

Vous pouvez partager vos connaissances en l?améliorant (comment ?) selon les recommandations des projets correspondants.

Perceptron avec 2 entrées et une fonction d'activation à seuil

Le perceptron peut être vu comme le type de réseau de neurones le plus simple. C'est un classifieur linéaire. Ce type de réseau neuronal ne contient aucun cycle (en anglais feedforward neural network). Le perceptron a été inventé en 1957 par Franck Rosenblatt au Cornell Aeronautical Laboratory, inspiré par la théorie cognitive de Friedrich Hayek et celle de Donald Hebb.

Dans sa version simplifiée, le perceptron est mono-couche et n'a qu'une seule sortie à laquelle toutes les entrées sont connectées. Les entrées et la sortie sont booléennes.

Le potentiel post-synaptique $\sum W_i e_i$ où $W i$ est le poids de l'entrée $e i$ .

La fonction d'activation est la fonction de Heaviside (la fonction signe est parfois utilisée) $H(x)=\left\ 0 & \mathrm & x < 0 \\ 1 & \mathrm & x \ge 0\end\right.$ , avec $x = \sum W_i e_i + b$ . Ici, b définit le seuil à dépasser pour que la sortie soit à 1.

On trouve fréquemment une variante de ce modèle de base dans laquelle la sortie prend les valeurs -1 et 1 au lieu de 0 et 1.

[] Apprentissage du Perceptron

{{ceci est un petit exemple en C des possibilités du perceptron:

#include <stdio.h>
#include <stdlib.h>
/* numeros est une matrice que l'ordinateur va essayer d'apprendre */
int numeros[10][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,0,
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,
}
,
{
1,1,1,1,1,
1,0,0,0,1,
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,
1,0,0,0,1,
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,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
}
};
 float poids[10][30];
 /* la fonction init affecte un "poids" de manière aléatoire à chacune des zones de la matrice à apprendre */
void init()
{
    int i,j;
    for(j=0;j<10;j++)
    {
       for(i=0;i<30;i++)
          poids[j][i] =(float)(rand()%100-50);
    }
}
 /* la fonction calcul retourne 1 si le poids total de la ligne num de la matrice est >0 ou 0 sinon */
 /*             elle ne prend que les poids correspondant à un 1 dans la ligne num                      */
int calcul(int num, int num2)
{
    int i;
    float total=0;
    for(i=0;i<30;i++)
    {
       if(numeros[num][i] ==1)
       {
          total=total+poids[num2][i] ;
       }   
    }
return total>0?1:0;
}
 /* la fonction calcule_poids retourne le poids (+1,-1 ou 0)*(caractère 1 ou 0 de la matrice)*10 */
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 apprendre relie les poids à la matrice à apprendre */
int apprendre(int num, int num2)
{
int i;
int result=calcul(num,num2);
for(i=0;i<30;i++)
{
   poids[num2][i]  = calcule_poids((float)poids[num2][i] , num ==num2,result, numeros[num][i] );
}
return 1;
}
 
int main(int argc, char *argv[])
{
  int i,j,compt=0;
  init();/*initialise les poids*/
  while(compt<31) /* j'ai mis 31essais car en fait au 29ème il a tout appris!! */
  /* dans la version originale de ce prog, il n'y avait que 7 caractères à apprendre, et il lui fallait seulement 12 essais pour tout apprendre */
  {
  printf("\n séquence d'apprentissage n°%d\n",compt);
  /*quand ça affiche la matrice d'identité, c'est que les données sont apprises correctement*/
  /* sinon on affiche ce qui a été appris pour le moment */
  for(j=0;j<10;j++)
  {
     for(i=0;i<10;i++)
     {
        printf("\t%d",calcul(i,j));
     }
  printf("\n");
  }
  /*on fait relier tous les poids avec tous les caractères*/
  for(j=0;j<10;j++)
  {
     for(i=0;i<10;i++)
        apprendre(i,j);
  }   
  printf("\n");
  for (j=0; j<100000000; j++); /*séquence de pause*/
  compt=compt+1;        
}
  return 0;
}
}}