Perceptron

Perceptron

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.


Sommaire

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 Wi est le poids de l'entrée Xi.


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 = Wi + α(Y.Xi)


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 = Wi + α(YtY)Xi


où Yt représente la sortie attendu, W'i représente le poid i corrigé enfin α représente 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 grace a 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

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


Wikimedia Foundation. 2010.

Contenu soumis à la licence CC-BY-SA. Source : Article Perceptron de Wikipédia en français (auteurs)

Игры ⚽ Поможем написать реферат

Regardez d'autres dictionnaires:

  • Perceptrón — Saltar a navegación, búsqueda Perceptrón con 2 entradas El Perceptrón es un tipo de red neuronal artificial desarrollado por Frank Rosenblatt, véase Perceptrón multicapa, también puede entenderse como perceptrón la neurona artificial y unidad… …   Wikipedia Español

  • Perceptron — Perceptrons redirects here. For the book of that title, see Perceptrons (book). The perceptron is a type of artificial neural network invented in 1957 at the Cornell Aeronautical Laboratory by Frank Rosenblatt.[1] It can be seen as the simplest… …   Wikipedia

  • Perceptron — Einfaches dreilagiges feed forward Perzeptron mit fünf Input , drei Hidden und einem Output Neuron, sowie zwei Bias Neuronen Das Perzeptron (engl. perceptron, nach engl. perception, „Wahrnehmung“) ist ein vereinfachtes künstliches neuronales Netz …   Deutsch Wikipedia

  • Perceptrón — ► sustantivo masculino TECNOLOGÍA Sistema autoadaptativo que consiste en un circuito que realiza percepciones análogas a las del cerebro animal. * * * Un perceptrón se refiere a una neurona artificial y también como a la unidad básica de… …   Enciclopedia Universal

  • Perceptron multicouche — Le Perceptron multicouche est un Classifieur linéaire de type réseau neuronal formel organisé en plusieurs couches au sein desquelles une information circule de la couche d entrée vers la couche de sortie uniquement ; il s agit donc d un… …   Wikipédia en Français

  • Perceptrón multicapa — Saltar a navegación, búsqueda El perceptrón multicapa es una red neuronal artificial (RNA) formada por múltiples capas, esto le permite resolver problemas que no son linealmente separables, lo cual es la principal limitación del perceptrón… …   Wikipedia Español

  • Perceptron-Konvergenz-Theorem — Einfaches dreilagiges feed forward Perzeptron mit fünf Input , drei Hidden und einem Output Neuron, sowie zwei Bias Neuronen Das Perzeptron (engl. perceptron, nach engl. perception, „Wahrnehmung“) ist ein vereinfachtes künstliches neuronales Netz …   Deutsch Wikipedia

  • Perceptrón multicapa — En el estudio de la inteligencia artificial, se conoce un perceptrón multicapa como aquella red neuronal artificial (RNA) cuyas neuronas se encuentran distribuidas en capas, de modo que las salidas de todas las neuronas que constituyen una… …   Enciclopedia Universal

  • perceptron — noun a) an element, analogous to a neuron, of an artificial neural network consisting of one or more layers of artificial neurons b) a network of such elements. Syn: McCulloch Pitts neuron …   Wiktionary

  • perceptron — m IV, D. u, Ms. perceptronnie; lm M. y techn. «elektroniczne urządzenie rozpoznające; receptor z przetwarzaniem informacji» ‹skrót.› …   Słownik języka polskiego

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”