IA : Interface Homme-‐Machine Chapitre 5 . Réseaux de neurones
mul>couches
Yu LI, yu.li@u-‐picardie.fr
Laboratoire MIS, Université de Picardie Jules
Verne, France
Plan
• Limita>on du perceptron
• Réseaux de neurones mul>couches
• Méthode du gradient
• Méthode de la retropropaga>on
Du perceptron a` l’appren>ssage profond
1957 (RosenblaT) Perceptron
1969 (Minsky, Papert) Problème XOR
1986 (Rumelhart et. al) Backpropaga>on 1998 (LeCun et. al) LeNet
2010 (Hinton et. al) Deep Neural Networks 2014 GoogleNet – 22 couches
2015 Incep>on (Google) – Deep Dream
2016 ResidualNet (Microsod/Facebook) – 152
couches
Limita>on du perceptron
• Un exemple simple de problème qu'un Perceptron ne peut pas résoudre, est l’opérateur logique XOR.
• Problème XOR:
– Soit deux variables x1, x2 pouvant prendre les valeurs 0 ou 1,
comment diviser le plan en trouvant une droite séparant les points bleus (0, 0) et (1,1) des points rouges (0, 1) et (1,0) ?
Limita>on du perceptron
• Pour ce faire, il nous faut rajouter une couche cachée, dans le but de diviser le plan en 3 sous-‐ensembles (modélisés par deux lignes P1 et P2 ), soit :
– L'espace inférieur à P1, dont la sor>e doit être égale à 0 – L'espace entre P1 et P2, dont la sor>e doit être égale à 1 – L'espace supérieur à P2, dont la sor>e doit être égale à 0
Réseaux de neurones mul>couches
• C'est ainsi qu'apparaissent les réseaux dit « mul>couches ».
• Un réseau de neurones mul>couches comporte :
– Une couche d´entrée.
– Une ou plusieurs couches cachées.
– Une couche de sor>e.
Descente de Gradient
• Lors de son appren>ssage, le réseau de neurones cherche à résoudre un problème d'op>misa>on pour meTre à jour des différents poids .
• Les poids sont ini>alisés aléatoirement au début. A chaque itéra>on, l'algorithme va calculer l'erreur qu'il commet en comparant la sor>e aTendue et la sor>e prédite :
– E = (y-‐yt)^2/2
• CeTe erreur E est prise en compte comme fonc>on
objec>ve à tout le modèle. Cependant, nous souhaitons meTre à jour les poids wij, en fonc>on du poids actuel.
• Pour ce faire, l'algorithme va u>liser une technique appelée
« Descente de Gradient », afin d'affiner au fur et à mesure les poids, en fonc>on de l'erreur commise.
Descente de Gradient
• Supposons que l’on souhaite minimiser une fonc>on f(x), la méthode de descente de
gradient consiste à faire évoluer les x dans la
direc>on inverse du gradient.
Exemple : Descente de Gradient
# gd.py!
import sys!
def f(x):!
! return x ** 2 / 2 - 2 * x !
! !
def g(x): !
! return x - 2 !
def gd(x_start, p, e, n):!
! x = x_start !
! for i in range(n) : !
! ! grad = g(x) !
! ! print('epochs = {0}, grad = {1}, x = {2}, dx = {3}, y = {4}'.format(i, grad, x, abs(grad * p), f(x))) !
! ! if abs(grad) < e: !
! ! ! break!
! ! x -= grad * p !
! return x !
! !
gd(int(sys.argv[1]),float(sys.argv[2]), float(sys.argv[3]), int(sys.argv[4]))!
Exemple : Descente de Gradient
python gd.py -‐10 0.5 0.1 30
epochs = 0, grad = -‐12, x = -‐10, y = 70, dx = 6.0 // x0 epochs = 1, grad = -‐6.0, x = -‐4.0, y = 16.0, dx = 3.0 // x1 epochs = 2, grad = -‐3.0, x = -‐1.0, y = 2.5, dx = 1.5 // x2 epochs = 3, grad = -‐1.5, x = 0.5, y = -‐0.875, dx = 0.75 // x3
epochs = 4, grad = -‐0.75, x = 1.25, y = -‐1.71875, dx = 0.375 // x4
epochs = 5, grad = -‐0.375, x = 1.625, y = -‐1.9296875, dx = 0.1875 // x5
epochs = 6, grad = -‐0.1875, x = 1.8125, y = -‐1.982421875, dx = 0.09375 // x6
epochs = 7, grad = -‐0.09375, x = 1.90625, y = -‐1.99560546875, dx = 0.046875 //x7
Rétropropaga>on d’erreur (BP)
• Dans notre cas, ceTe fonc>on est définie de la
façon suivante :
Rétropropaga>on d’erreur (BP)
• 1. Ini>alisa>on de tous les poids du réseau
• 2. Pour chaque exemple (x,yt) de S faire :
– Calculer la prédic>on y
– Calculer E(e) = (y− yt )^2/2
– MeTre à jour pour tous les poids avec la méthode de descente de gradient
– Jusqu’à sa>sfac>on d’un critère d’arrêt
• 3. Retourner le réseau
Exemple : XOR
• Problème : Soit deux variables x1, x2 pouvant prendre les valeurs 0 ou 1, comment diviser le plan en trouvant une droite séparant les points (0, 0) et (1,1) des points (0, 1) et (1,0) ?
