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).

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.

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 » :

Fonctionnement

À l’entrée d’un perceptron linéaire à seuil, 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\) :

Implémentation

Pour implémenter en Python un perceptron linéaire à seuil il faut :

• une structure de données pour les poids synaptiques : une liste w de nombre flottants
• une structure de données pour les valeurs d’entrée : une liste x de nombre flottants
• un algorithme de propagation : une fonction propagation qui possède deux paramètres (deux listes pour les entrées et les poids) et retourne un entier (valeurs -1 ou 1) ou un booléen

Il est conseillé d’encapsuler les éléments concernant le perceptron dans une classe :

class Perceptron:
    """ Classe définissant un perceptron linéaire à seuil
    """
    def __init__(self, n = 2):
        """ n : taille du vecteur d'entrée
        """
        # les poids synaptiques
        self.W = [0]*(n+1) # biais = W[0]

    def propager(self, X):
        """ Propagation de l'entrée X (taille n)
            return : int (-1 ou 1)
        """
        ...
        return ...

Représentation

L’action d’un perceptron linéaire à seuil à 2 entrées peut être représentée, sur un graphique à 2 dimensions, par une droite (ligne de séparation) séparant en deux un ensemble de points colorés (échantillon de données).

Le module ia_utils (ia_utils.py) propose des fonctions de génération de données et de représentation basées sur la bibliothèque Matplotlib :

• load_data(nom_fichier) → (liste, liste) : charge les données depuis un fichier CSV, classées en 2 classes (de tailles égales si pas de 3ième colonne)
• gen_data(n) → (liste, liste) : génère aléatoirement un échantillon de données classées en 2 classes de n éléments
• afficher(perceptron, donnees) : trace une représentation graphique des données (points colorés) et de la droite de séparation définie par le perceptron

Exemple :

from ia_utils import *

class Perceptron:
    ...
p = Perceptron(2)
p.W = [-2.0, 1.76, 3.34]
c1, c2 = load_data("data_6.csv")
afficher(p, (c1, c2))

Produit l’affichage :

Apprentissage

Le perceptron doit être doté d’un algorithme d’apprentissage supervisé qui permet de déterminer automatiquement ses poids synaptiques \(W\).

Si le problème est linéairement séparable, le lemme de séparabilité linéaire stricte montre que la règle du perceptron permet de trouver une séparatrice entre les deux classes.

Pour réaliser un apprentissage, il faut utiliser un échantillon fini de \(m\) données labellisées \(S=\{\left(X_1,s_1\right) , \dots , \left(X_m,s_m\right)\}\).

Exemple :

des données …

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.

• 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\neq f\left(X_k, W)\right)\)
      alors \(W \gets W+s_k\;X_k\)
  • appliquer les poids \(W\) au perceptron

def rosenblatt(self, donnees):
    """ Algorithme du perceptron de Rosenblatt
        détermine les poids synaptiques
        à partir d'un échantillon de données
        donnees : tuple(list[tuple(float, float)], # données de classe -1 
                        list[tuple(float, float)]) # données de classe 1
    """

Algorithme du gradient stochastique

Si les données ne sont pas linéairement séparables, il faut utiliser un perceptron multicouche, associé à un algorithme plus complexe, qui agit par rétropropagation.

Algorithme d’apprentissage :

• Initialiser aléatoirement les poids ;
• Calculer la sortie pour un vecteur d’entrée donné ;
• Calculer la prédiction, si la différence entre la valeur attendue et la prédiction est positive alors erreurprédiction
  = 1, sinon erreur =0 ;
• Mettre à jour les poids : Δui=η(Sattendue–erreur)×ei
  avec η le taux d’apprentissage (0<η<1)

Recommencer jusqu’à que l’erreur de prédiction soit acceptable

Remarque : \(\eta\) représente le taux d’apprentissage. S’il est mal choisi il peut y avoir oscillation ou le calcul très long !

sources : https://members.loria.fr/FSur/enseignement/apprauto/seance5.pdf
https://www.unilim.fr/journees-interdisciplinarite/761
https://www.labri.fr/perso/nrougier/downloads/Perceptron.pdf