Le perceptron
Un perceptron est un algorithme d’apprentissage supervisé de classifieurs binaires.
Il est composé de neurones formels élémentaires, assemblés en réseaux de neurones artificiels à propagation directe (feed-forward), inspirés du fonctionnement des neurones biologiques.
- Nombre de neurones : 100 milliards
- Nombre moyen de connexions par neurone : 10 000
- 1mm3 de cortex contient un 1 milliard de connexions
Un classifieur binaire est une fonction capable de décider si une entrée, représentée par un vecteur de nombres, appartient ou non à une classe spécifique.
Le perceptron linéaire
Un perceptron linéaire est un type de classificateur linéaire, c’est-à-dire d’un algorithme de classification qui effectue ses prédictions sur la base d’une fonction prédictive linéaire.
Exemple : classification en deux classes d’un ensemble de points dans un espace à deux dimensions
Le rôle de ce perceptron est de classifier n’importe quel point de l’espace, défini par ses coordonnées \(x,y\), dans l’une des deux classes « rouge » ou « bleu » :
Le perceptron simple couche
Le plus simple perceptron est un perceptron linéaire à seuil, qui ne contient qu’un seul neurone.
À l’entrée, on trouve un vecteur de \(n\) valeurs réelles \(X=(x_1, x_2, \dots, x_n)\).
À chaque entrée est associée un poids ou coefficient synaptique défini par le vecteur de taille \(n\) : \(W=(w_1, w_2, \dots,w_n)\).
Remarque : \(X\) et \(W\) sont deux vecteurs de \(\mathbb{R}^n\)
On peut également utiliser un coefficient supplémentaire \(b\), associé à aucune valeur d’entrée, appelé biais.
Remarque : on choisira le plus souvent d’intégrer le biais au vecteur des coefficients synaptiques, en fixant une entrée à 1. Le biais prendra alors le nom \(w_0\) si on le place au début du vecteur \(W\) ou \(w_{n+1}\) si on le place à la fin.
La sortie est une unique valeur binaire calculée selon la fonction prédictive \(f\):
\(\large{\displaystyle s=f(X)=h\left(w_0+\sum_{i=1}^n x_i\cdot w_i\right)}\)
Le rôle de la fonction d’activation \(h\) est d’obtenir un résultat binaire. Cela peut être fait par l’application d’un seuil (fonction de Heaviside), dont la valeur est simplement le biais \(b\) :
Soit le perceptron suivant permettant de classer des points du plan (de coordonnées \((x_p,y_p)\)) en deux classes, "rouge" ou "bleu" (la sortie \(c\) vaut 1 pour la couleur bleu, 0 pour la couleur rouge) :
On cherche à connaitre la couleur du point de coordonnées \((x_p,y_p)=(1,1; 0,5)\).
Apprentissage
Exemple : la fonction logique ET
La fonction logique ET peut être définie par sa table de vérité :
| \(x\) | \(y\) | \(x\;ET\;y\) |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Mais on peut également utiliser un perceptron simple, capable de classifier le résultat \(x\;ET\;y\).
\(\large{\displaystyle r=h\left(w_b+x\cdot w_x+y\cdot w_y\right)}\)
Mais comment déterminer les coefficients \(w_x\), \(w_y\) et \(w_b\) ?
Approche par l’équation de la ligne séparatrice
La ligne séparatrice étant une droite d’équation : \(y=a\;x+b\), on peut identifier les coefficients \(a\) et \(b\) et utiliser, par exemple, les valeurs suivantes :
\(a=-1\) et \(b=\frac{3}{2}\)
On peut alors écrire l’équation de la droite sous la forme :
\(ax-y+b=0\), soit \(x+y-\frac{3}{2}=0\)
On identifie donc :
- \(w_x=1\)
- \(w_y=1\)
- \(w_b=-\frac{3}{2}\)
Avec un algorithme
Algorithme de Rosenblatt
L’algorithme le plus simple est celui inventé en 1957 par Frank Rosenblatt. Il converge vers une solution (vecteur \(W\) des poids synaptiques) si et seulement si l’échantillon de données entré est linéairement séparable.
Pour cet algorithme, les deux classes doivent être dans \(\{-1;1\}\).
- initialiser à zéro tous les poids \(W\) du perceptron (y compris le biais !) ;
- tant que le perceptron commet des erreurs (autrement dit : \(\exists k\) tel que \(f(X_k)\neq s_k\) :
- pour \(k\) allant de \(1\) à \(m\) (taille de l’échantillon d’apprentissage) :
- si \(s_k \times f\left(X_k, W)\right)\leq 0\) (pas le même signe = pas la même classe !)
alors \(W \gets W+s_k\;X_k\)
- si \(s_k \times f\left(X_k, W)\right)\leq 0\) (pas le même signe = pas la même classe !)
- appliquer les poids \(W\) au perceptron
- pour \(k\) allant de \(1\) à \(m\) (taille de l’échantillon d’apprentissage) :
Dans l’exemple de la fonction ET :
\(\displaystyle r=h\left(w_b+x\cdot w_x+y\cdot w_y\right)\)
Étape 0 :
- \(w_x=0\)
- \(w_y=0\)
- \(w_b=0\)
\(\displaystyle r=h\left(0+x\cdot 0+y\cdot 0\right)=0\)
| \(x\) | \(y\) | classe de \(x\;ET\;y\) |
\(\displaystyle r=h\left(0+x\cdot 0+y\cdot 0\right)\) |
|---|---|---|---|
| 0 | 0 | -1 | 0 |
| 0 | 1 | -1 | 0 |
| 1 | 0 | -1 | 0 |
| 1 | 1 | 1 | 0 |
Il y a une erreur pour x=1 et y=1 ; on doit corriger les poids :
- \(w_x\gets w_x\)
- \(w_y\gets w_y\)
- \(w_b\gets w_b\)
Pouvoir de séparation
L’augmentation du nombre de couches et du nombre de neurones accroit le pouvoir de séparation :
Le perceptron simple couche ne permet pas, par exemple de modéliser la fonction XOR. Pour cela, il faudra utiliser un perceptron multicouches.
Perceptron multicouche
Le perceptron multicouches est organisé en plusieurs couches. La première est reliée aux entrées, puis chaque couche est reliée à la couche précédente, la dernière prosuisant les sorties.
Sources : https://www.labri.fr/perso/nrougier/downloads/Perceptron.pdf
https://fr.wikipedia.org/wiki/Perceptron_multicouche