Perceptron

Cet article est une ébauche concernant l’informatique. Vous pouvez partager vos connaissances en l’améliorant (comment ?) selon les recommandations des projets correspondants.

Le perceptron a été inventé en 1957 par Frank Rosenblatt au Cornell Aeronautical Laboratory, inspiré par la théorie cognitive de Friedrich Hayek et celle de Donald Hebb.

Définition

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). 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 biaisé est représenté par $Z = \sum W_i X_i - \theta$. Ici, θ définit le seuil (ou biais) à dépasser pour que la sortie Y soit à 1, et W_i est le poids de l'entrée X_i.

La fonction d'activation est la fonction de Heaviside (la fonction signe est parfois utilisée)

$Y = H(Z)=\left\{\begin{matrix} 0 & \mathrm{si} & Z < 0 \\ 1 & \mathrm{si} & Z \ge 0\end{matrix}\right.$

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.

La règle de Hebb

La règle de Hebb établie par Donald Hebb est une règle d'apprentissage des réseaux de neurones artificiels dans le contexte de l'étude d'assemblées de neurones.

Cette règle suggère que lorsque deux neurones sont excités conjointement, il se crée ou renforce un lien les unissant.

Dans le cas d'un neurone artificiel seul utilisant la fonction signe comme fonction d'activation cela signifie que :

W'_i = W_i + α(Y.X_i)

où W'_i représente le poids i corrigé et α représente le pas d'apprentissage.

Cette règle n'est malheureusement pas applicables dans certains cas bien que la solution existe.

La règle d'apprentissage du Perceptron

Le perceptron de Frank Rosenblatt est très proche de la règle de Hebb la grande différence est qu'il tient compte de l'erreur observée en sortie.

W'_i = W_i + α(Y_t − Y)X_i

où Y_t représente la sortie attendue, W'_i le poids i corrigé et α le pas d'apprentissage.

Exemple de programme

Le programme qui suit est en language C et permet l'apprentissage de la fonction AND par un perceptron.

//apprentissage de la fonction and par un perceptron

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

void apprentissage (int*,float*,int, int,int);   // apprentissage grâce à la modification des poids

int calculsortieperceptron (int*,float*,int);    // calcule la sortie du perceptron

int calculsortieatendu (int*,int);               // calcule la sortie attendue

void affinfo(int*,float*,int, int,int);          // affiche le résumé d'une itération

int calculentre (int*,int);                      // compteur binaire à n bits perméttent de générer des entrées automatiquement

int main(void)
{
    const int n=4;                              // n est le nombre d'entrée +1 pour le seuil theta
    int E[n],O,i,T,compteur, flag,ent;          // O = sortie du perceptron et T sortie attendu
    float W[n];                                 // tableau des poids associé aux entrées E[i]
    flag=0;
    compteur=0;                                 // met le compteur d'itération à 0

    srand(time (NULL));
    rand();

    // première étape initialisation des poids synaptique et des entrées////////
    for (i=0;i<n;i++)                                                         //
    {                                                                         //
         W[i]= (double)(rand()*5)/RAND_MAX;                                   //
         printf ("le poids %d est initialise a :%f \n",i+1,W[i]);             //
         E[i]=0;                                                              //
    }                                                                         //
        E[0]=1; //entrée de theta est toujours à 1                            //
    ////////////////////////////////////////////////////////////////////////////
  
    // cycle d'apprentissage////////////////////////////////////////////////////
    while (flag!=1 || ent!=0)                                                 //
    {                                                                         //
          if (ent==0) flag=1;                                                 //
          compteur=compteur+1;                                                //
          O=calculsortieperceptron (&E[0],&W[0],n);                           //
          T=calculsortieatendu (&E[0],n);                                     //
          affinfo(E,W,n,O,T);                                                 //
          if (O!=T)                                                           //
          {                                                                   //
               flag=0;                                                        //
               apprentissage (&E[0],&W[0],n,O,T);                             //
          }                                                                   //
          ent=calculentre (&E[0],n);                                          //
    }                                                                         //                   
    ////////////////////////////////////////////////////////////////////////////
    printf ("le perceptron a appris la fonction en %d iterations",compteur);
    getchar();
    return 0;
}

void apprentissage (int* E,float* W,int n,int O,int T)
{
    int i=0;
    
    for (i=0;i<n;i++)
    {
        *W=*W+(T-O)*1**E;
        E=E+1;
        W=W+1;
    } 
}

int calculsortieperceptron (int* E,float* W,int n)
{
    int i,O=0;  
      
    for (i=0;i<n;i++)
    {
        O=O+*W**E;
        E=E+1;
        W=W+1;
    }
    if (O>0) O=1;
    if (O≤0) O=0;
    
    return O;
}

void affinfo(int* E,float* W,int n,int O,int T)
{
     int i;
     printf ("\n\n\n");
     for (i=1;i<n;i++)
     {
         printf ("E%d=%d  ",i,*(E+i));
         printf ("W%d=%f\n",i,*(W+i));   
     }     
     printf ("theta=%f\n\n",*W);
     printf ("sortie O=%d\n",O);
     printf ("sortie attendu T=%d\n",T);
}

int calculentre (int* E,int n)
{
     int e1,i,e2;
     e1=0;
     n=n-1;
     E=E+1;
     
     for (i=0;i<n;i++)
     {
         e1=e1+(*(E+i)<<(i));
     }
     e1=e1+1;
     if (e1>(pow(2,n)-1)) e1=0;
     for (i=0;i<n;i++)
     {
         e2=pow(2,i);
         *(E+i)=(e1 & e2)/e2;
     } 
     return e1;    
}

int calculsortieatendu (int* E,int n)
{
    int i,T=0;
    T=*(E+1)&*(E+2);
    for (i=3;i<n;i++)
    {
        T=T&*(E+i);
    }
    return T;
}

Voir aussi

Le perceptron : Algorithme et théorèmes

Réseau neuronal artificiel

Bibliographie

• F. Rosenblatt (1958), "The perceptron: a probabilistic model for information storage and organization in the brain",

- repris dans J.A. Anderson & E. Rosenfeld (1988), Neurocomputing. Foundations of Research, MIT Press