Recherche des poids d'un perceptron

Dans ce TP, on applique la descente de gradient stochastique pour calculer les poids d'un perceptron.
Comme en cours, on considère un perceptron réel à sortie binaire : sa sortie vaut 1 si l'activation du perceptron est positive ou nulle, elle vaut 0 sinon.

v0 : cas d'une fonction qui peut être calculée par un perceptron

Rappel : DGS pour calculer les poids d'un perceptron

Comme on l'a vu en cours, pour calculer les poids d'un perceptron, le principe de la DGS est le suivant :

on a un jeu d'exemples constitué de N données d'entrées et des N valeurs de sortie attendues. Chaque donnée est décrite par P attributs.
On note x_i la i^è donnée et x_i,j l'attribut j de la i^è donnée. On note y_i la sortie attendue pour la i^è donnée. Le i^è exemple est donc le couple (x_i, y_i).
On effectue la descente de gradient stochastique :
1. On initialise les P poids avec une valeur quelconque.
2. nb_erreurs = 1
3. Tant-que nb_erreurs > 0:
  1. nb_erreurs = 0
  2. Pour chaque exemple x_i:
    1. on calcule la sortie s du perceptron pour cet exemple.
    2. d = s - y_i
    3. Si d est non nulle :
      1. nb_erreurs = nb_erreurs + 1
      2. biais = biais - η d
      3. Pour chaque poids j : p_j = p_j - η d x_i,j
C'est fini.

Mise en œuvre

Écrire le programme python qui réalise cette DGS. Comme dans le TP 2, on suppose que l'on dispose de deux listes :

entrées qui contient les données, donc N sous-listes comprenant chacune P valeurs ;
sorties qui contient les sorties attendues pour chaque donnée, soit N valeurs 0 ou 1.

À chaque itération du Tant-que, affichez le nombre d'erreurs. Ce nombre doit décroître au fil des itérations. Vous pouvez prendre η = 0,01 (ou une autre valeur).

À faire :

Réalisez une DGS pour chacune des fonctions logiques à deux entrées que nous avons rencontrées précédemment et qui peuvent être calculées par un perceptron (ET, OU, NON-ET, NON-OU).
Faites-le également pour ces 4 fonctions logiques à 4 entrées.

Représentation graphique

Comme on l'a vu en cours, les poids d'un perceptron représentent une droite dans le cas où le perceptron a deux entrées (un plan s'il en a 3, etc).
Dans le cas où il y a deux entrées, on peut réaliser une représentation graphique des exemples, de la droite résultant de la DGS et aussi les droites au fil des itérations.
Pour réaliser une représentation graphique, je vous fournis les quelques lignes de python qui suivent.

import matplotlib.pyplot as plt

def debut_figure (entrées, sorties):
    fig, ax = plt.subplots ()
    couleurs = []
    for i in range (len (sorties)):
        if sorties [i] == 1:
            couleurs.append ("red")
        else:
            couleurs.append ("blue")
    for i in range (len (sorties)):
        ax.scatter (entrées [i] [0], entrées [i] [1], color = couleurs [i], s = 2)
    return fig, ax

def ajoute_droite (ax, a, b, c):
    x1 = [0, 5]
    y1 = [-a/c, -(5*b+a)/c]
    ax.plot (x1, y1, linestyle = ":")

def ajoute_dernière_droite (fig, ax, a, b, c):
    x1 = [0, 5]
    y1 = [-a/c, -(5*b+a)/c]
    ax.plot (x1, y1, color = "red", linestyle = "-", linewidth= 3)
    fig.show ()

Copiez-les et collez-les au début de votre programme en python. Pas la peine de chercher à comprendre comment elles fonctionnent, on va juste les utiliser dans ce TP. On fait comme cela :

Avant de commencer la DGS, vous ajoutez la commande : fig, ax = debut_figure (entrées, sorties). Cette commande affiche le plan avec les données, un disque bleu pour les données correspondant à la sortie 0, un disque rouge pour les données correspondant à la sortie 1.
À la fin du corps du Tant-que, vous ajoutez la commande : ajoute_droite (ax, a, b, c). a, b et c sont les 3 poids (a et le biais). Cette commande affiche la droite correspondant à ces 3 poids.
Une fois que vous êtes sorti du Tant-que, ajoutez la commande : ajoute_dernière_droite (fig, ax, a, b, c). Cette commande affiche la droite correspondant aux poids finaux par un trait gras rouge.

Pour la ET logique, si vous prenez initialement a = b = -1 et c = 2, vous devez obtenir le graphique suivant :

On y voit :

la droite initiale est celle dont la représentation commence à l'ordonnée 0,5 (la plus basse) et se termine le plus haut (3) à droite du graphique.
La droite finale est en trait gras, rouge. Elle semble horizontale, mais elle est légérement penchée.
Toutes les autres droites constituent cette zone plus ou moins colorée : il y en a beaucoup d'où cet effet ; elles balaient le plan entre la droite initiale et la droite finale.

Remarque : sur les ordinateurs en salle de TP, si aucun graphique ne s'affiche, essayer de modifier la fonction ajoute_dernière_droite () en remplaçant fig.show () par plt. show().

Mise en œuvre sur les iris

Les iris constituent un jeu de données célèbre.
L'objectif est ici d'appliquer la DGS sur un sous-ensemble du jeu de données iris.
Pour cela, copiez-collez les entrées et sorties ci-dessous. Ce sont les longueurs et les largeurs des pétales de 11 iris, soit un sous-ensemble du jeu de données complet qui en comprend 150. Les sorties donnent une information sur l'espèce de l'iris, codée par 0 ou 1.

entrées = [[1.4, 0.2],
           [4.0, 1.3],
           [1.7, 0.4],
           [1.6, 0.2],
           [3.9, 1.2],
           [5.1, 1.6],
           [1.5, 0.3],
           [4.0, 1.0],
           [1.9, 0.4],
           [4.1, 1.3],
           [1.7, 0.5]]
sorties = [0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0]

Si vous prenez a = b = -1 et c = 1, en quelques itérations, vous obtenez cette figure :

Prenez d'autres valeurs de poids initiales et refaites une DGS à partir de celles-ci.

Si votre programme fonctionne correctement, vous pouvez le tester sur l'ensemble complet des 150 iris. Pour cela, copiez-collez ces quelques instructions python qui stockent dans entrées et sorties les 150 exemples.

from sklearn import datasets
iris = datasets.load_iris()
entrées = iris.data [:,2:4]
sorties = []
for i in range (len (iris.target)):
    if iris.target [i] == 0:
        sorties.append (0)
    else:
        sorties.append (1)

Exécutez la DGS sur ces 150 exemples. En prenant a = 1, b = -3 et c = 0, vous devez obtenir la figure suivante :

Prise en compte de tous les attributs des iris

Chaque iris est en fait décrit par 4 attributs : longueur et largeur des sépales, longueur et largeur des pétales. On peut appliquer la même méthode que ci-dessus en prenant en compte les 4 attributs par un perceptron ayant 4 entrées (+ le biais).

Pour cela, copier-coller les instructions suiavntes :

from sklearn import datasets
iris = datasets.load_iris()
entrées = iris.data [:,[2,3,0,1]]
sorties = []
for i in range (len (iris.target)):
    if iris.target [i] == 0:
        sorties.append (0)
    else:
        sorties.append (1)

entrées est maintenant un tableau de 150 iris (lignes) et 4 attributs (colonnes). Vous pouvez appliquer ce qui a été fait plus haut à un perceptron à 4 entrées (+ son biais).
Cette fois-ci, ne faites pas de représentation graphique car les fonctions données plus haut ne sont pas adaptées à ce cas de figure (elles supposent que les données sont décrites par 2 attributs seulement). (Vous pouvez essayer de les modifier pour qu'elles fonctionnent avec 4 attributs. Pour cela, commencez par bien comprendre comment fonctionnent les fonctions que j'ai donné plus haut.)
À la place d'un graphique, vous affichez le nombre d'erreurs commises par le perceptron à chaque itération de la boucle Tant-que de la DGS. Ce nombre doit atteindre 0 dans cet exemple.

v1 : cas d'une fonction qui ne peut pas être calculée sans erreur par un perceptron

D'une manière générale, le perceptron ne peut pas calculer l'étiquette de tous les exemples sans commettre d'erreurs.
Comme il n'est pas facile de savoir à l'avance si un perceptron réussira à calculer correctement la sortie attendue pour tous les exemples, il faut que l'algorithme de calcul des poids fonctionne même lorsqu'il n'arrive pas à ne faire aucune erreur.

Principe

Dans le cas où le perceptron ne peut pas calculer la sortie attendue pour tous les exemples, on ne s'arrête plus quand le nombre d'erreurs est nul mais quand ce nombre d'erreurs ne diminue plus.

À faire : modifiez votre programme pour qu'il fonctionne ainsi. Testez-le sur la fonction logique ou-exclusif.

D'une manière générale, même si le nombre d'erreurs ne diminue pas, les poids continuent d'être modifiés. Aussi, un meilleur critère d'arrêt est plutôt d'itérer la DGS tant que les poids continuent d'être corrigés significativement. On peut donc s'arrêter quand la somme des corrections des poids réalisées dans la boucle Pour est inférieure à un certain seuil (10^-3 par exemple).

Test de votre programme sur les iris

On reprend le jeu de données des iris avec 2 attributs, mais on l'utilise différemment.
Pour cela, remplacez les lignes indiquées plus haut par celles-ci :

from sklearn import datasets
iris = datasets.load_iris()
entrées = iris.data [:,2:4]
sorties = []
for i in range (len (iris.target)):
    if iris.target [i] != 2:
        sorties.append (0)
    else:
        sorties.append (1)

Dans ce cas, les données correspondant aux deux étiquettes sont mélangées, il n'existe pas de droite les séparant correctement.
Si vous avez bien fait ce qu'il faut, votre programme doit s'arrêter alors que le nombre d'erreurs n'est pas nul (mais il est faible) et la droite ne sépare pas parfaitement les points bleus des points rouges.

Pour finir

Le source de votre programme doit respecter les points suivants :

il doit commencer par un commentaire indiquant son titre, son objet, ses auteurs, la date de réalisation.
Chaque fonction doit commencer par un commentaire indiquant au minimum ce que fait la fonction, le sens des paramètres, les pré-conditions et ce que la fonction retourne.
Le type des paramètres des fonctions doit être indiqué, ainsi que le type de la valeur retournée.

Pour finir, vous m'envoyez votre/vos script(s) par email, en mettant votre binôme en cc.