Université de Strasbourg

Intelligence artificielle
Licence 3 - UFR Mathématique - Informatique
TP – Classification d’espèces d’iris
avec un réseau de neurones artificiel
Partie 1

Le but de ce TP est de travailler à la classification d’espèces d’Iris en utilisant un réseau de neurones.

Objectifs :
— Observer les données, comprendre leur nature et comment les adapter (si besoin) pour les utiliser
avec le modèle d’apprentissage réseau de neurones.
— Comprendre le fonctionnement d’un réseau de neurones pour le mettre en œuvre dans un pro-
gramme.

1 Chargement des données

¥ Charger les données iris.csv avec Pandas.

¥ Séparer les attributs (X) des étiquettes (y).
¥ Mettre de côté 15% des données d’entrainement pour le test du modèle.

1.1 Prétraitement

Les étiquettes de nos données sont des catégories décrites textuellement (Iris-setosa,
Iris-versicolor et Iris-virginica). Nous devons changer ces étiquettes de façon à pouvoir les ma-
nipuler facilement. Une première idée est de leur attribuer un identifiant numérique (e.g. Iris-setosa
= 1, Iris-versicolor = 2 et Iris-virginica = 3). Le problème de cet encodage en apprentissage
automatique, c’est qu’il peut entrainer un biais lors de l’apprentissage du modèle à cause de la relation
d’ordre a (pas dans le cas de tous les modèles, mais les réseaux de neurones artificiels y sont sensibles).
Une alternative intéressante est d’utiliser un encodage one-hot. C’est un encodage binaire dont tous les
bits sont à zéro sauf celui correspondant à la classe effective :

class_Iris-setosa class_Iris-versicolor class_Iris-virginica

0 0 1
0 1 0
1 0 0

La bibliothèque Pandas permet de réaliser ce type d’encodage : y = pd.get_dummies(y).

NB Pour un réseau de neurones, le pré-traitement des données inclus également une normalisation des
données. Dans le cas du jeu de données des iris, les attributs sont tous sur le même ordre de grandeur,
on se passera donc de normalisation pour ce TP.

a. Ici, on ne peut pas dire que Iris-versicolor < Iris-virginica : on ne veut pas que notre modèle infère ce type de
relation. Si on reprend l’exemple de “aller jouer au golf” alors dans ce cas oui, la relation d’ordre peut être intéressante :
pluvieux = 1 < ensoleillé = 2

1
2 Construction du modèle de réseau de neurones artificiel
Comme on l’a vu en cours, un réseau de neurones type “perceptron multi-couches” n’est rien d’autre
qu’un ensemble de matrices stockant les paramètres du réseau sur chaque couche. On travaillera donc
uniquement sur des ensembles de matrices, pour stocker les paramètres (poids et biais) d’une part, et les
données d’autre part. Pour tout ça, la bibliothèque Numpy sera notre amie. Vous aurez aussi besoin de
quelques fonctions d’activation et de fonctions de coûts pour mesurer la véracité de vos prédictions par
rapport aux résultats attendus : pour cela, vous avez à disposition un fichier utility.py qui contient
une classe définissant des méthodes statiques que vous pourrez utiliser.

Questions
1. Quelles fonctions d’activation sont à disposition dans utility.py ?
2. Que renvoient ces fonctions ?
3. Rappelez pourquoi l’utilisation d’un softmax est intéressante dans le cas d’un problème de classi-
fication.

2.1 Architecture du réseau de neurones

On propose de définir l’architecture illustrée sur la figure 1. Ce modèle est composé de L = 3 couches :
2 couches cachées de respectivement 3 (l = 1) et 2 (l = 2) unités chacune ainsi qu’une couche de sortie
(l = L = 3).
Les entrées et sorties du modèle sont déterminées par les données (4 attributs en entrée et one-hot de
3 bits en sortie).
Les matrices de poids sont de dimensions nl × nl−1 où nl (le nombre de lignes) est le nombre d’unités
sur la couche l et nl−1 (le nombre de colonnes) est le nombre d’unités sur la couche l − 1 (C.f. figure 2).
Les biais sont représentés par des matrices (nl , 1) b .
Pour le formuler différemment, la matrice de poids sur la couche l a pour nombre de lignes le nombre
d’unités sur la couche l, et pour nombre de colonnes le nombre d’unités sur la couche l − 1.

b[1]
b[2]
x1 b[3] z1 a1
z1 a1
x2 z1 a1 z2 a2
z2 a2
x3 z2 a2 z3 a3
z3 a3
x4

[0] (in) [1] [2] [3] (out)

Figure 1 – Réseau de neurones artificiel à 2 couches cachées. Les biais de chaque couche sont représentés par une unité,
mais il s’agit bien d’un vecteur (nl , 1)

b. Oui, techniquement c’est un vecteur mais un vecteur (nl , 1), donc une matrice de nl lignes et 1 colonne.

2
  
w w21 w31 w41
 11 
[1]
W = w12
 
w22 w32 w42 
 
w13 w23 w33 w43

Figure 2 – Matrice de poids pour la couche l = 1. Cette matrice a pour nombre de lignes le nombre d’unités sur la couche
1 et pour nombre de colonnes le nombre d’unités (ici le nombre d’attributs) sur l − 1.

Sur papier, représentez les matrices de poids / vecteurs de biais pour les couches l = 2 et L (la
couche de sortie).

2.2 Représentation d’un modèle de réseau de neurones en Python

Les éléments de base pour représenter un réseau de neurones artificiel sont les suivants :
— un nombre de couches cachées et leur dimensions
— une liste de matrices de poids
— une liste de matrices de biais
— une liste de matrices d’entrées pondérées
— une liste de matrices d’activations
— un taux d’apprentissage (η)
— une fonction d’activation pour les unités des couches cachées
— un nombre d’epoch pendant lequel entrainer le modèle
Voici une manière de définir une liste qui contiendra n layers + 1 matrices de poids dans le construc-
teur de votre future classe : self.weights = [None] * (self.n_layers + 1) (initialise une liste de
n layers + 1 éléments à None, i.e. [None, None, ..., None]).
Si on note spécifiquement n layers + 1, c’est parce que n layers représente le nombre de couches
cachées, le +1 représente la couche de sortie.

2.2.1 Constructeur de la classe

¥ Créez une classe NeuralNet et définissez son constructeur en utilisant les éléments ci-dessus. On
propose d’utiliser le prototype suivant :
1 def __init__ ( self , X_train = None , y_train = None , X_test = None , y_test = None ,
2 h i d d e n _ l a y e r _ s i z e s =(4 ,) , activation = ’ tanh ’ , learning_rate =0.01 , epoch =200) :
3 # A faire ...

Comment la variable d’instance hidden layer sizes permet-elle de spécifier le nombre de couches
cachées et le nombre d’unités sur chacune de ces couches ?

2.2.2 Initialization des matrices de paramètres (poids et biais)

Pour initialiser les paramètres, on va simplement assigner des valeurs aléatoires comprises dans [−1; 1].
Pour cela, on peut utiliser la fonction numpy.random.uniform(low=0.0, high=1.0, size=None) c .
Avec le paramètre size, nous allons pouvoir spécifier les dimensions de nos matrices (que vous devez
avoir déjà calculé lorsque l’architecture vous a été présentée !). Il faut faire cette opération d’initialisation
pour chaque couche cachée puis terminer par la couche de sortie. On propose le prototype suivant :
def __weights_initialization(self, n_attributes, n_classes):, n attributes correspondant
au nombre d’attributs dans le jeu de données, et n classes au nombre de classes possible.

¥ Mettez en œuvre cette fonction et appelez là dans le constructeur de votre classe.

c. https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.random.uniform.html

3
 2.2.3 Propagation avant
¥ Mettez en œuvre la fonction de propagation avant. Pour chaque couche l de votre réseau, vous
devez calculer les entrées pondérées de la couche et les activations :

Z [l] = W [l] A[l−1] + b[l]

A[l] = g(Z [l] )
N’oubliez pas que la couche de sortie L est activée avec la fonction softmax) ! Pour la première couche
cachée, A[l−1] correspond aux entrées du réseau.

Nous allons travailler en mode online, c’est-à-dire utiliser les instances une par une. Les données passées
en paramètres à votre réseaux (X et y) contiennent des lignes représentant les instances. Dans le dataframe
Pandas, chaque instance a est un vecteur (1,4). Pour pouvoir les multiplier avec vos matrices de poids,
il faut les transposer (ici on montre la transposition instance par instance, pour un apprentissage “en
ligne”) :
1 X_train = X_train . to_numpy ()
2
3 for i in range ( len ( X_train ) ) :
4 instance = np . array ([ X_train [ i ]]) . transpose ()
5 print ( instance . shape )
6 print ( instance )
7
8 """
9 (4 , 1)
10 [[5.1]
11 [3.5]
12 [1.4]
13 [0.2]]
14 """

Votre fonction de propagation avant doit renvoyer le tuple (ŷ, erreur). L’erreur est informative et est
calculée avec la fonction cross entropy cost. ŷ est la prédiction de votre réseau pour l’instance passée
en paramètre à la fonction de propagation avant.

Et la suite ? ?
Si vous arrivez jusqu’ici, vous avez déjà fait un gros boulot !

Il reste à mettre en œuvre la rétropropagation du gradient et à mettre à jour les paramètres, ainsi que de
spécifier plus largement une époque d’entrainement (mélange des données / passe avant / passes arrière
et mise à jour des paramètres / passe avant sur le jeu de test) : cela sera l’objet du prochain TP !