TP 4 : Réseaux de Neurones

Introduction

Dans sa forme la plus pure, un réseau de neurones (neural networks en anglais) est simplement une structure de données permettant de représenter une fonction f: ℝⁿ → ℝ^m comme une composition complexe de “petites” fonctions . Cette structure de données existe depuis les débuts de l’intelligence artificielle en tant que discipline de recherche : elle était vue à l’origine comme une modélisation informatique du cerveau et de son fonctionnement et une croyance répandue dans certaines communautés de recherche dans les années 50 était qu’on pourrait créer un “cerveau électronique” imitant le cerveau humain. On s’est rapidement rendu compte que cette vision était utopique et que les ordres de grandeur qu’on savait traiter à l’époque (et qu’on sait encore traiter aujourd’hui) sont loin des ordres de grandeur du cerveau humain. L’analogie entre les réseaux de neurones et le cerveau humain a laissé sa marque dans le vocabulaire utilisé quand on parle de réseau de neurones. Cependant, elle atteint rapidement ses limites en pratique et nous essaierons ici de ne pas trop utiliser l’intuition des réseaux de neurones comme un cerveau électronique mais de voir cela comme des objets mathématiques et informatique permettant de calculer des choses.

Si on a rapidement abandonné l’espoir d’imiter le cerveau humain, les réseaux de neurones restent des structures de données très intéressantes en pratique pour l’intelligence artificielle pour les raisons suivantes :

• D’un point de vue théorique, un réseau de neurones suffisamment grand peut approximer n’importe quelle fonction f: Rⁿ → ℝ^m, c’est donc une famille de structures très générale. Ce théorème mathématique n’est cependant pas suffisant pour justifier leur succès.
• Les réseaux de neurones sont une famille de structures très modulaire, c’est-à-dire qu’on peut connecter entre eux différents réseaux de neurones pour exprimer des fonctions de complexes. On peut et on a donc construit de façon incrémentale des réseaux pouvant résoudre des tâches de plus en plus complexes.
• On sait apprendre les réseaux de neurones de façon très efficace. Étant donnée un jeu de données pour un problème de classification ou de régression, on peut mettre à jour un réseau de neurones efficacement pour apprendre la fonction sous-jacente. Cette efficacité repose sur deux choses : d’une part, l’algorithme permettant de mettre à jour un réseau de neurones peut être implémenté en un petit nombre d’opération sur le réseau. D’autre part, on a su l’implémenter de façon très efficace et massivement parallèle sur des architectures connues sous le nom de GPU (originalement développées pour les cartes graphiques des ordinateurs) ce qui a permis d’apprendre sur des jeux de données extrêmement grands.

Aujourd’hui ils sont utilisés pour des tâches d’apprentissage très variées : reconnaissance d’images, génération de texte, jeux, traduction automatique, robotique etc.

Les réseaux de neurones représentent une famille de structure très riches, puissantes et très utilisées en pratique. Cependant, nous sommes encore loin d’avoir une méthode complètement générale permettant d’apprendre n’importe quoi à partir d’exemples. L’utilisation des réseaux de neurones demande une bonne compréhension du problème d’apprentissage sous-jacent pour assurer qu’on choisit une structure adaptée au problème qu’on veut résoudre, qu’on normalise correctement les données pour que le réseau généralise suffisamment bien. On se repose en général pour cela sur des observations empiriques passées sans parfois exactement comprendre pourquoi cela marche. Les réseaux de neurones souffrent aussi d’un désavantage majeur par rapport aux arbres de décision vus au TP précédent : il est difficile de comprendre ce que fait le réseau une fois qu’on l’a appris depuis les données. On peut vérifier empiriquement qu’il donne de bons résultats sur les données que l’on veut traiter, mais on peut difficilement acquérir une intuition de pourquoi cela marche ni de garanties formelles.

Dans ce TP, nous n’arborderons pas encore ces aspects qui seront approfondis l’an prochain dans le cours Exploiter les ensembles de données. Le but de ce TP est de se familiariser avec le concept de réseau de neurones et d’essayer de comprendre à quel point leur fonctionnement et leur précision dépendent de choix structurels en amont.

Le neurone formel

Un neurone formel est une fonction N: ℝⁿ → ℝ^m de la forme :

N(x₁,…,x_n) = F(∑_i = 1..nw_ix_i+b).

C’est donc la composition d’une fonction affine ∑_iw_ix_i + b et d’une fonction F appelée la fonction d’activation. Les coefficients w_i sont appelés les poids et b est appelé le biais du neurone.

On représente généralement un neurone formel graphiquement comme suit :

Plusieurs fonctions d’activation ont été considérées dans la litérature. On donne ici une liste non-exhaustive :

• La fonction signe : signe définie par signe(x) =  − 1 si x < 0 et signe(x) = 1 sinon.
• La fonction Heaviside: H(x) = 0 si x < 0 et H(x) = 1 sinon.
• La fonction sigmoïde σ : x ↦ e^x/(1+e^x)
• ReLU (Rectified Linear Unit) : ReLU(x) = max (0,x).

Le problème des fonctions signe et H est qu’elles ne sont pas continues, ce qui empêche d’utiliser de nombreux outils mathématiques provenant de la théorie de l’optimisation. On peut voir la fonction sigmoïde comme une “approximation” continue de la fonction signe et la fonction ReLU comme une “approximation” de la fonction Heaviside.

Réseaux de neurones

Un réseau de neurones est une composition successive de neurones formels. Par exemple (les biais ont été enlevés pour alléger le dessin) :

Pour des raisons pratiques, tous les réseaux de neurones que l’on considèrera sont organisés par couches (layers en anglais). La première couche, appelée couche d’entrée (input layer), est la couche qui contient les paramètres d’entrée que l’utilisateur peut choisir. La dernière couche, appelée couche de sortie (output layer), sont les valeurs que le réseau calcule en fonction des valeurs données en entrée. Les couches intermédiaires sont appelées couches cachées (hidden layers) puisque leurs valeurs durant le calcul ne sont pas explicitement données à l’utilisateur.

Même si en théorie on pourrait faire autrement, en pratique, on ne considère que des réseaux où tous les neurones ont la même fonction d’activation. De plus, chaque neurone de la couche i est supposé être connecté à tous les neurones de la couche i + 1. Cela veut dire que chaque neurone de la couche i + 1 reçoit s_i valeurs en entrée, où s_i est le nombre de neurone dans la couche i, une entrée par neurone de la couche précédente. Un neurone v de la couche i + 1 calcule donc une fonction de la forme F(∑_j ≤ siw_v, ja_j) où a_j est la valeur de sortie du neurone j de la couche i et w_v, j est un poids d’entrée spécifique au neurone v.

Dans ce cas, un réseau de neurones est entièrement caractérisé par :

1. La fonction d’activation des neurones,
2. Le nombre de couches c (donc avec c − 2 couches cachées)
3. Les tailles (s₁,…,s_c) de chacune des couches (s₁ est le nombre d’entrées, s_c le nombre de sorties)
4. L’ensemble W des poids qui sont entre chaque neurone.

Un réseau de neurones de ce type calcule donc une fonction N: ℝ^s₁ → ℝ^s_c, de la forme N₁ ∘ N₂ ∘ … ∘ N_c − 1 où N_i est la fonction N_i: ℝ^s_i → ℝ^s_i + 1 calculée par la couche i. On peut d’ailleurs voir que chaque N_i est une fonction affine composée avec la fonction d’application F. Cela explique en partie pourquoi les GPU forment une architecture très adaptée aux réseaux de neurones puisqu’ils sont construits pour faire rapidement des calculs matriciels, ce qui est exactement ce dont on a besoin pour calculer des fonctions affines.

Empiriquement, on a pu vérifier que les performances des réseaux de neurones s’améliorent avec la profondeur du réseau, c’est-à-dire le nombre de couches du réseau. Les puissances de calcul actuel combiné avec les architectures de type GPU ont permis d’entraîner des réseaux de neurones assez profond sur des grosse quantité de données pour résoudre des tâches par apprentissage qu’on pensait impossible jusqu’ici. Cette approche porte le nom de deep learning.

Apprentissage supervisé

Dans cette partie, on va rapidement expliquer comment on peut utiliser les réseaux de neurones pour réaliser une tâche d’apprentissage supervisé pour de la classification. Le but est de vous donner le vocabulaire nécessaire pour comprendre l’outil présenté à la partie suivante.

Pour un problème où on cherche à classifier des vecteurs de dimension n dans m classes, on va choisir un réseau de neurones avec une couche d’entrée de taille n et une couche de sortie de taille m. On a donc un réseau qui calcule une fonction de N: ℝⁿ → ℝ^m. Implicitement, on voit N(x) comme une fonction associant un score à chaque classe. On veut que N(x)_c soit grand lorsque x est de classe c et petit sinon. On voit donc N(x) comme une fonction calculant (de façon non normalisée) la probabilité que x soit de classe c.

Lorsqu’on veut apprendre avec un réseau de neurones, on commence par fixer sa structure (on parle parfois d’hyperparamètres) : on choisit les fonctions d’activations, le nombre et la taille de chaque couche cachée. On choisit aussi de façon aléatoire les poids W₀ du réseau. On démarre donc avec une fonction N(x;W₀). On mesure à quel point cette fonction est bonne sur les données D qu’on a dans notre jeu de données avec une fonction L(W₀) qui mesure l’erreur (loss en anglais) de N(⋅;W₀) sur les données. Le but est de trouver W^* tel que L(W^*) est minimale.

Quelque soit la fonction d’erreur L choisie, la phase d’apprentissage est toujours la même : on cherche à trouver W^* qui minimise L(W). On utilise pour cela la descente de gradient. Pour cela, on utilise le fait que L(W) est (en général) une fonction dérivable selon chaque coordonnée de W. La descente de gradient est la méthode consistant à mettre à jour W incrémentalement de la façon suivante converge en général vers un minimum (local) :

W_i + 1 = W_i − α∇L(W_i).

Dans cet algorithme, α est appelé le pas (learning rate en anglais) et indique à quelle vitesse on suit le gradient. Un α trop grand risque de donner de mauvais résultats car on risque d’osciller autour d’une valeur optimale, un α trop petit convergera trop doucement. On choisit en général α de façon adaptative (intuitivement, grand au début puis de plus en plus petit).

Aller plus loin

Fonction d’erreur

Une fonction d’erreur souvent considérée pour la classification est la fonction softmax définie par :

L(W) = (1/|D|)∑_{(x,c) ∈ D}  − log ℓ(x,c)

où ℓ(x,c) = e^N(x;W)_c/∑_ze^N(x;W)_z. Implicitement, on suppose que le vecteur de sortie N(x;W) contient, pour chaque classe c, le logarithme de la probabilité que x soit dans la classe c. On souhaite donc que ℓ(x,c) soit grand lorsque N “classe bien” x, c’est-à-dire que N(x,c) est grand.

Calcul efficace du gradient

Nous ne rentrons pas trop dans les détails ici mais un aspect permettant aux réseaux de neurones de passer à des grandes échelles est la façon dont on peut faire une descente de gradients sur L(W). En effet, on peut montrer que calculer ∇L(W) peut être fait très rapidement via un algorithme connu sous le nom de backpropagation. L’idée est qu’on peut calculer le gradient ∇n pour chaque neurone n du réseau dans une couche i à partir des gradients ∇n′ des neurones dans la couche i + 1. On propage donc cette information depuis la dernière couche vers la première pour obtenir ∇L(W) rapidement puis on met à jour W. Ces deux opérations peuvent être traduites en des opérations matricielles, accentuant encore l’avantage matériel d’utiliser des GPU.

Gradient stochastique

Dans quasiment tous les cas, l’erreur L(W) s’exprime sous la forme (1/n)∑_iℓ(x_i,c_i,W) pour un jeu de données D = (x₁,c₁), …, (x_n,c_n), c’est-à-dire que L(W) est une moyenne des erreurs ℓ commises sur chaque élément du jeu de données. Lorsque n est grand, calculer L(W) explicitement est trop coûteux. Plutôt que de calculer ∇L(W), on préfère parfois mettre à jour W en lui ajoutant  − α∇ℓ(x_i,c_i,W) plutôt que  − α∇L(W) qui est plus long à calculer. L’algorithme du gradient stochastique consiste à mettre à jour W ainsi : on commence par mélanger le jeu de données aléatoirement et on définit W_i + 1 = W_i − α∇ℓ(x_i,c_i,W). Une fois qu’on a atteint le dernier élément du jeu de données, on le mélange à nouveau et on recommence.

Le processus de mettre les poids à jour en traversant tout le jeu de données s’appelle une epoch. En général, on entraîne un réseau de neurones epoch par epoch, jusqu’à avoir une erreur stable.

Expériences

On va faire quelques expériences sur le site http://playground.tensorflow.org/ qui permet de joueur avec des petits réseaux de neurones et des petits jeux de données. Dans les questions suivantes, on gardera les options par défaut du logiciel sauf lorsqu’on vous demande explicitement de les modifier.