Notes de cours - Département d`informatique et de recherche

Transcription

Notes de cours IFT6266 H12
Release 2012.01.05
Université de Montréal, DIRO
March 11, 2012
CONTENTS
1
2
3
IFT6266: Plan de chaque cours
1.1 2 Avril . . . . . . . . . .
1.2 29 Mars . . . . . . . . . .
1.3 26 Mars . . . . . . . . . .
1.4 22 Mars . . . . . . . . . .
1.5 19 Mars . . . . . . . . . .
1.6 15 Mars . . . . . . . . . .
1.7 12 Mars . . . . . . . . . .
1.8 1 Mars . . . . . . . . . .
1.9 27 Février . . . . . . . . .
1.10 20+23 Février . . . . . .
1.11 13+16 Février . . . . . .
1.12 6+9 Février . . . . . . . .
1.13 2 Février . . . . . . . . .
1.14 30 Janvier . . . . . . . . .
1.15 26 Janvier . . . . . . . . .
1.16 23 Janvier . . . . . . . . .
1.17 19 Janvier . . . . . . . . .
1.18 16 Janvier . . . . . . . . .
1.19 12 Janvier . . . . . . . . .
1.20 9 Janvier . . . . . . . . .
1.21 5 Janvier . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction rapide à l’apprentissage machine pour l’IA
2.1 Intelligence . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Intelligence artificielle . . . . . . . . . . . . . . . . . . . . . .
2.3 Apprentissage machine . . . . . . . . . . . . . . . . . . . . . .
2.4 Formaliser l’apprentissage . . . . . . . . . . . . . . . . . . . .
2.5 Apprentissage supervisé . . . . . . . . . . . . . . . . . . . . .
2.6 Apprentissage non supervisé . . . . . . . . . . . . . . . . . . .
2.7 Généralisation locale . . . . . . . . . . . . . . . . . . . . . . .
2.8 Représentations locales ou distribuées, généralisation non locale
Introduction aux algorithmes d’apprentissage profonds
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
5
5
5
5
5
5
5
6
6
6
6
6
6
6
6
7
7
7
7
7
8
.
.
.
.
.
.
.
.
9
9
9
10
10
10
11
11
11
13
i
3.1
3.2
3.3
3.4
3.5
3.6
3.7
4
5
6
Profondeur . . . . . . . . . . . . . . . . . . . . . . . .
Motivations pour les architectures profondes . . . . . .
Manque de profondeur . . . . . . . . . . . . . . . . . .
Architecture profonde du cerveau . . . . . . . . . . . .
Profondeur des processus cognitifs . . . . . . . . . . .
Partage statistique . . . . . . . . . . . . . . . . . . . .
Percée dans l’apprentissage des architectures profondes
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13
14
14
14
15
15
16
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
calcul efficace du gradient
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
19
20
20
21
21
21
22
Introduction aux perceptrons multi-couches (réseaux de neurones à propagation avant)
5.1 Réseaux de neurones multi-couches . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Critères d’entraînements communs et non-linéarités de sortie . . . . . . . . . . . . . .
5.3 L’algorithme de rétropropagation . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4 Régression logistique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
25
25
26
26
28
.
.
.
.
.
.
.
.
.
29
29
29
30
31
31
31
32
33
33
Introduction à l’apprentissage par descente de gradient
4.1 Le gradient . . . . . . . . . . . . . . . . . . . . . . .
4.2 Descente de gradient . . . . . . . . . . . . . . . . . .
4.3 Descente de gradient stochastique . . . . . . . . . . .
4.4 Descente de gradient stochastique par mini-lots . . . .
4.5 Inertie (momentum) . . . . . . . . . . . . . . . . . .
4.6 Choisir l’échéancier du pas de gradient . . . . . . . .
4.7 Graphes de flot, dérivée en chaîne et rétropropagation :
L’entraînement de réseaux de neurones multi-couches
6.1 Problème fondamentalement difficile d’optimisation
6.2 Choix de l’architecture . . . . . . . . . . . . . . . .
6.3 Normalisation des entrées . . . . . . . . . . . . . .
6.4 Traitement des sorties désirées . . . . . . . . . . . .
6.5 Codage des sorties désirées et des entrées discrètes .
6.6 Algorithme d’optimisation . . . . . . . . . . . . . .
6.7 Initialisation des paramètres . . . . . . . . . . . . .
6.8 Contrôle de la saturation . . . . . . . . . . . . . . .
6.9 Contrôle de la capacité effective . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
Le défi d’entraîner des réseaux de neurones profonds
35
8
Auto-encodeurs débruitants vs auto-encodeurs ordinaires
37
9
Modèles probabilistes pour les architectures profondes
9.1 Rappels sur les modèles graphiques probabilistes . . .
9.2 Inférence . . . . . . . . . . . . . . . . . . . . . . . .
9.3 Inférence approximative . . . . . . . . . . . . . . . .
9.4 Inférence par MCMC . . . . . . . . . . . . . . . . .
9.5 Échantillonage de Gibbs . . . . . . . . . . . . . . . .
9.6 Le Gradient dans un Champs de Markov Log-Linéaire
9.7 Marginalisation sur les variables cachées . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
39
40
41
41
42
42
43
10 La Machine de Boltzmann
45
10.1 La Machine de Boltzmann Restreinte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
ii
10.2 Gibbs dans les RBMs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
11 Entraînement des RBMs
47
11.1 Divergence Contrastive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
11.2 Divergence Contrastive Persistente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
12 RBMs empilés et DBNs
12.1 Deep Belief Networks . . . . . . . . . . . . . . . .
12.2 Dépliement d’une RBM et équivalence RBM - DBN
12.3 Inférence approximative dans les DBNs . . . . . . .
12.4 Deep Boltzmann Machine . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
49
49
50
51
51
13 Contents
13.1 IFT6266: Course Outline . . . . . . . . . . . . . . . . . . . . . . . . .
13.2 Very Brief Introduction to Machine Learning for AI . . . . . . . . . . .
13.3 Introduction to Deep Learning Algorithms . . . . . . . . . . . . . . . .
13.4 Introduction to Gradient-Based Learning . . . . . . . . . . . . . . . . .
13.5 Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)
13.6 Training Multi-Layer Neural Networks . . . . . . . . . . . . . . . . . .
13.7 The challenges of training deep neural networks . . . . . . . . . . . . .
13.8 Denoising autoencoders vs. ordinary autoencoders . . . . . . . . . . . .
13.9 Probabilistic models for deep architectures . . . . . . . . . . . . . . . .
13.10 The Boltzmann Machine . . . . . . . . . . . . . . . . . . . . . . . . . .
13.11 Training RBMs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.12 Stacked RBMs and DBNs . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
53
53
57
60
64
68
71
76
77
78
82
84
86
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
iii
iv
Notes de cours IFT6266 H12, Release 2012.01.05
English version
CONTENTS
1
2
CONTENTS
CHAPTER
ONE
IFT6266: PLAN DE CHAQUE COURS
Tableau résumé des cours et lectures (cliquer sur la date pour les détails de chaque cours)
3
4
Date
2 avril
29
mars
26
mars
Sujets
Examen
Révision
À lire en priorité
Réseaux à convolution
22
mars
19
mars
15
mars
12
mars
1 mars
27
février
20+23
février
13+16
février
6+9
février
2
février
30
janvier
26
janvier
23
janvier
19
janvier
16
janvier
12
janvier
9
janvier
5
janvier
Gradient profond.
DAE vs AE
Défi de la profondeur
Article sur le Neocognitron.
Article sur LeNet.
Tutoriel sur les réseaux à convolution.
fin de Présentation de Yoshua Bengio.
Auto-encodeurs débruitants vs auto-encodeurs ordinaires.
Le défi d’entraîner des réseaux de neurones profonds.
Pré-entraînement
Contracting AE
DBMs
Présentation de Dumitru Erhan.
Présentation de Yoshua Bengio.
Article sur les Contracting Auto-Encoders et le Manifold Tangent
Classifier
Article sur les Contracting Auto-Encoders
Deep Boltzmann Machine.
DBNs
RBMs empilés et DBNs.
RBMs
La Machine de Boltzmann Restreinte.
Modèles probabilistes
Modèles probabilistes pour les architectures profondes.
Modèles probabilistes,
Lancer de jobs au LISA
DAE
Intro aux Modèles probabilistes pour les architectures profondes.
Jobman.
Denoising Auto-Encoders
Auto-encodeurs
Section 4.6 de Learning Deep Architectures for AI.
python, numpy, Theano
Régression logistique
Réseaux de neurones
Documentation sur python, numpy, et Theano. Exemple avec la
Régression logistique. Notes sur l’entraînement des MLPs.
Efficient Backprop. Intro au tutorial profond de Theano.
Démarrage du tutoriel.
Notes sur le calcul du gradient.
Contracting AE et MTC
Le calcul du gradient
Intro aux architectures
profondes
Intro aux architectures
profondes
Intro au cours
Intro à l’apprentissage
Notes introductoires sur les architectures profondes, Sec. 1 de
Learning Deep Architectures for AI. Notes sur le gradient.
Notes introductoires sur les architectures profondes, Sec. 1 de
Learning Deep Architectures for AI.
plan de cours .
diapos. . Notes introductoires sur l’apprentissage, Sec. 1 et 2 de
Scaling Learning Algorithms towards AI.
Chapter 1. IFT6266: Plan de chaque cours
1.1 2 Avril
• Examen théorique à livre ouvert
1.2 29 Mars
• Révision en vue de l’examen
1.3 26 Mars
• Réseaux à convolution
– Neocognitron
– LeNet
– Tutoriel sur les réseaux à convolution
1.4 22 Mars
• Propagation du gradient supervisé dans les réseaux profonds: Présentation de Yoshua Bengio Mai
2010.
• Auto-encodeurs débruitants vs auto-encodeurs ordinaires.
1.5 19 Mars
• Comprendre l’effet du pré-entraînement non-supervisé: Présentation de Yoshua Bengio Mai 2010.
• Le défi d’entraîner des réseaux de neurones profonds.
1.6 15 Mars
• Comprendre l’effet du pré-entraînement non-supervisé: Présentation de Dumitru Erhan Mars 2010.
• Comprendre l’effet du pré-entraînement non-supervisé: Présentation de Yoshua Bengio Mai 2010.
1.7 12 Mars
• Articles sur les Contracting Auto-Encoders et le Manifold Tangent Classifier
1.1. 2 Avril
5
1.8 1 Mars
• Article sur les Contracting Auto-Encoders.
1.9 27 Février
• Deep Boltzmann Machine.
1.10 20+23 Février
• RBMs empilés et DBNs.
1.11 13+16 Février
• La Machine de Boltzmann Restreinte.
1.12 6+9 Février
• Suite des Modèles probabilistes pour les architectures profondes.
1.13 2 Février
• Tutorial sur les auto-encodeurs débruitants
• Intro aux Modèles probabilistes pour les architectures profondes.
1.14 30 Janvier
• Auto-encodeurs
1.15 26 Janvier
• Suite de l’entraînement des réseaux de neurones:
– Contrôle de la capacité: L’entraînement de réseaux de neurones multi-couches
• Auto-encodeurs
– Survol des auto-encodeurs: section 4.6 de Learning Deep Architectures for AI
6
1.16 23 Janvier
• Introduction aux perceptrons multi-couches (réseaux de neurones à propagation avant)
– L’algorithme de rétropropagation
– Régression logistique
– L’entraînement de réseaux de neurones multi-couches
• Intro au tutoriel profond de Theano
1.17 19 Janvier
• Introduction aux perceptrons multi-couches (réseaux de neurones à propagation avant)
– Réseaux de neurones multi-couches
– Critères d’entraînements communs et non-linéarités de sortie
• Introduction à Theano
• Intro au tutoriel profond de Theano
1.18 16 Janvier
• Introduction à l’apprentissage par descente de gradient
– Graphes de flot, dérivée en chaîne et rétropropagation : calcul efficace du gradient
1.19 12 Janvier
• Introduction aux algorithmes d’apprentissage profond
– Percée dans l’apprentissage des architectures profondes
• Introduction à l’apprentissage par descente de gradient
– Le gradient
– Descente de gradient
– Descente de gradient stochastique
1.20 9 Janvier
• Introduction aux algorithmes d’apprentissage profonds
1.16. 23 Janvier
7
1.21 5 Janvier
• Introduction au cours, objectifs du cours, modalités d’évaluation (plan de cours)
• Introduction rapide à l’apprentissage machine pour l’IA
English version
8
CHAPTER
TWO
INTRODUCTION RAPIDE À
L’APPRENTISSAGE MACHINE POUR
L’IA
Les sujets abordés ici sont couverts dans cette présentation.
2.1 Intelligence
La notion d’intelligence peut être définie de bien des façons. Ici, nous la définissons comme la capacité de
prendre la bonne décision, selon un certain critère (par exemple, survivre et se reproduire, pour la plupart des
animaux). Pour prendre de meilleures décisions, des connaissances sont nécessaires, et elles doivent être
dans un format opérationnel: elles doivent pouvoir être utilisées pour interpréter des données sensorielles et
prendre des bonnes décisions en conséquence.
2.2 Intelligence artificielle
Les ordinateurs possèdent déjà certaines formes d’intelligence, grâce à des programmes, créés par les humains, qui leur permettent de « faire des choses » considérées utiles (nous considérons généralement la
bonne décision comme celle qui est la plus utile). Cependant, il existe de nombreuses tâches faciles à
réaliser pour des animaux ou des humains, mais qui restent hors d’atteinte pour les ordinateurs, au début du
21 e siècle. La plupart de ces tâches font partie de ce que l’on appelle l’intelligence artificielle (IA), ce qui
inclut les tâches de perception et de contrôle. Comment se fait-il que nous n’ayons pas réussi à écrire de
programmes réalisant ces tâches ? Je crois que la principale raison est que nous ne savons pas explicitement
(de façon formelle) comment résoudre ces tâches, même si notre cerveau (avec notre corps) est capable
de les réaliser de façon instinctive. Les connaissances permettant de réaliser ces tâches sont actuellement
implicites, mais nous avons des informations, des données qui nous viennent d’exemples (par exemple, des
observations de ce qu’un humain ferait dans certaines situations, étant donné un but). Comment faire pour
que des machines puissent acquérir ce genre d’intelligence ? Par l’apprentissage, c’est-à-dire l’utilisation de
données et d’exemples pour construire des connaissances opérationnelles.
9
2.3 Apprentissage machine
L’apprentissage machine (ou machine learning, ML) a une longue histoire, et de nombreux manuels couvrent ses principes. Parmi les manuels récents, je suggère :
• Christopher M. Bishop, *Pattern Recognition and Machine Learning*, 2007
• Simon Haykin, *Neural Networks: a Comprehensive Foundation*, 2009 (3rd edition)
• Richard O. Duda, Peter E. Hart and David G. Stork, *Pattern Classification*, 2001 (2nd edition)
Ici, nous allons nous concentrer sur certains concepts, qui sont les plus pertinents pour ce cours.
2.4 Formaliser l’apprentissage
Voici d’abord le formalisme mathématique le plus fréquemment utilisé pour décrire l’apprentissage. Nous
disposons d’exemples d’entraînement
D = {z1 , z2 , . . . , zn }
où les zi sont des exemples générés par un processus inconnu P (Z).
Nous avons également une fonction d’erreur L, qui prend comme arguments une fonction de décision f
et un exemple z, et qui renvoie un scalaire réel. Nous voulons minimizer l’espérance de L(f, Z) sous le
processus stochastique P (Z).
2.5 Apprentissage supervisé
Dans l’apprentissage supervisé, chaque exemple est une paire (entrée, cible): Z = (X, Y ), et f s’applique
à des exemples de X. Les deux exemples de problèmes supervisés les plus fréquents sont
• La régression : Y est un réel, ou un vecteur de réels, la sortie de f est dans le même espace que Y , et
l’erreur est souvent l’erreur quadratique:
L(f, (X, Y )) = kf (X) − Y k2
• La classification: Y est un entier fini (c’est-à-dire un symbole), qui correspond à l’indice d’une classe,
et la fonction d’erreur utilisée est souvent la log-vraisemblance conditionnelle négative, en interprétant
fi (X) comme une estimation de P (Y = i|X):
L(f, (X, Y )) = − log fY (X)
avec les contraintes suivantes:
fY (x) ≥ 0 ,
X
fi (X) = 1
i
10
Chapter 2. Introduction rapide à l’apprentissage machine pour l’IA
2.6 Apprentissage non supervisé
Dans l’apprentissage non supervisé, nous apprenons une fonction f qui aide à caractériser une distribution
inconnue P (Z). f peut être un estimateur de P (Z) directement (estimation de densité). Dans d’autre cas,
f essaie d’estimer les zones où la densité de probabilité se concentre.
Les algorithmes de partitionnement (clustering) divisent l’espace des entrées en différentes régions (souvent
autour d’un exemple “prototype”, ou d’un centroïde). Certains algorithmes de partitionnement créent des
partitions “dures” (par exemple, l’algorithme des k moyennes, ou k-means), où chaque exemple appartient
seulement à une région. D’autres construisent une partition “douce” (soft) (par exemple, un mélange de
gaussiennes), qui assigne à chaque Z une probabilité d’appartenir à chaque cluster.
D’autres algorithmes non supervisés apprennent une transformation qui construit une nouvelle représentation pour Z. Beaucoup d’algorithmes d’apprentissage profonds appartiennent à cette catégorie, l’analyse en
composantes principales (ACP, ou principal components analysis, PCA) également.
2.7 Généralisation locale
La grande majorité des algorithmes d’apprentissage exploitent un seul principe pour généraliser : la généralisation locale. Par exemple, un tel algorithme suppose que si un exemple d’entrée xi est proche d’un autre
exemple xj , alors les sorties correspondantes f (xi ) et f (xj ) doivent aussi être proches. Ce principe est
utilisé pour l’interpolation locale.
Ce principe est très puissant, mais il a ses limitations: et si on essaie d’extrapoler ? ou si la fonction
inconnue (cible) a beaucoup plus de variations que le nombre d’exemples d’entraînement? Dans ce cas, il
est impossible que la généralisation locale fonctionne, puisqu’il nous faut au moins autant d’exemples que
de creux et de bosses dans la fonction cible pour couvrir toutes ces variations et généraliser par ce principe.
Ce problème est lié à ce que l’on appelle la malédiction de la dimensionalité (ou fléau de la dimension,
curse of dimensionality). Lorsque l’espace des entrées est de haute dimension, le nombre de variations
de la fonction d’intérêt peut facilement être une fonction exponentielle du nombre de dimensions d’entrée.
Par exemple, imaginons que nous voulons distinguer 10 valeurs différentes pour chaque variable d’entrée
(chaque élément du vecteur d’entrées), et que les 10n configurations de ces n variables sont importantes ou
nous intéressent. En utilisant uniquement la généralisation locale, nous avons besoin d’au moins un exemple
pour chacune de ces 10n configurations pour pouvoir généraliser dans chacune d’elles.
2.8 Représentations locales ou distribuées, généralisation non locale
Un entier N peut être représenté par une séquence de B bits, avec N < B, telle que tous les bits valent
0 sauf le N -ième. C’est une représentation binaire locale. Le même entier peut être représenté par une
séquence de B = log2 N + 1 bits, qui contient la représentation habituelle de N en base 2. Cette représentation binaire est distribuée. Cet exemple nous montre qu’une représentation distribuée peut être plus efficace
qu’une représentation locale, et ce, de manière exponentielle. De manière générale, pour les algorithmes
d’apprentissage, les représentations distribuées ont la capacité de capturer “exponentiellement” plus de variations que les représentations locales, pour le même nombre de paramètres libres. Ainsi, ils ont le potentiel
2.6. Apprentissage non supervisé
11
d’une meilleure généralisation, puisque la théorie de l’apprentissage montre que le nombre d’exemples requis (pour atteindre un certain degré de performance en généralisation) pour ajuster O(B) degrés de liberté
effectifs est O(B).
La différence entre les représentations locales et distribuées peut aussi être illustrée par la différence entre
le partitionnement traditionnel, local, et l’analyse en composantes principales, ou les machines de Boltzmann restreintes (restricted Boltzmann machines, RBM), qui définissent des représentations distribuées. Par
exemple, k-means a besoin d’un vecteur de coordonnées pour chaque prototype (centroïde), c’est-à-dire un
vecteur pour chacune des régions distinguées par l’algorithme. L’ACP, au contraire, représente la distribution en gardant les directions où les variations sont les plus grande. Imaginons une interprétation simplifiée
de l’ACP, où tout ce qui nous intéresse, pour chaque direction de variation, est de savoir si la projection de la
donnée est au-dessus (ou en-dessous) d’un certain seuil. Avec d directions, on peut distinguer 2d régions. De
la même manière les RBMs définissent d hyperplans, et un bit indique si l’entrée est d’un côté ou de l’autre
de chaque hyperplan. Ainsi, une RBM associe une région de l’espace des entrées à chaque configuration
des bits de représentation (dans le vocabulaire des réseaux de neurones, ces bits correspondent à des unités
cachées). Le nombre de paramètres d’une RBM est environ le nombre de ces bits multiplié par le nombre
de dimensions de l’entrée.
Nous pouvons voir que le nombre de régions définies par une RBM, ou l’ACP, c’est-à-dire des représentations distribuées, croît selon l’exponentielle du nombre de paramètres, alors que le nombre de régions
définies par des algorithmes de partitionnement traditionnel (par exemple k-means, ou des mélanges de
gaussiennes), qui définissent des représentations locales, croît linéairement avec le nombre de paramètres.
Nous pouvons aussi voir que la RBM peut généraliser à une nouvelle région, c’est-à-dire à une configuration
des ses unités cachées, dans laquelle il n’y avait aucun exemple d’entraînement. C’est quelque chose qui
n’est pas possible pour les algorithmes de partitionnement classiques (ces algorithmes pourraient seulement
généraliser localement de façon triviale, en répétant ce qu’ils ont appris dans les régions voisines contenant
des exemples d’entraînement).
English version
12
Chapter 2. Introduction rapide à l’apprentissage machine pour l’IA
CHAPTER
THREE
INTRODUCTION AUX ALGORITHMES
D’APPRENTISSAGE PROFONDS
Pour une revue récente de l’apprentissage profond, voir: Yoshua Bengio, Learning Deep Architectures for
AI, Foundations and Trends in Machine Learning, 2(1), 2009
3.1 Profondeur
Les calculs effectués pour produire une sortie à partir d’entrées peuvent être représentés par un graphe
de flot: un graphe de flot est un graphe qui représente un calcul, dans lequel chaque nœud représente une
opération élémentaire et une valeur (le résultat de cette opération sur les enfants de ce nœud). Les nœuds
d’entrée n’ont pas d’enfants, et les nœuds de sortie n’ont pas de parents. Considérons l’ensemble des
opérations possibles dans chaque nœud, et l’ensemble des structures de graphes possibles, cela définit une
famille de fonctions.
Le graphe de flot de l’expression sin(a2 + b/a) peut être représenté par un graphe avec:
• deux noeuds d’entrée, a et b;
• un nœud pour la division, b/a, dont les entrées (les enfants) sont a et b;
• un nœud pour le carré, prenant seulement a comme entrée;
• un nœud pour l’addition, dont la valeur serait a2 + b/a, prenant comme entrées les nœuds a2 et b/a;
• un nœud de sortie calculant le sinus, dont la seule entrée est le nœud d’addition.
Une propriété particulière d’un tel graphe de flot est la profondeur: la longueur du plus long chemin depuis
une entrée jusqu’à une sortie.
La profondeur d’un réseau de neurones traditionnel (sans récurrence) peut être considérée comme égale
au nombre de couches (c’est-à-dire le nombre de couches cachées plus 1, pour la couche de sortie). Les
machines à vecteurs de support (support vector machines, SVM) ont une profondeur de 2: un premier
niveau pour la sortie des noyaux ou l’espace de redescription (feature space), et un deuxième niveau pour la
combinaison linéaire qui produit la sortie.
13
3.2 Motivations pour les architectures profondes
Les motivations principales pour étudier les algorithmes d’apprentissage pour des architectures profondes
sont les suivantes :
• Le manque de profondeur peut être nuisible
• Le cerveau a une architecture profonde
• Les processus cognitifs semblent être profonds
3.3 Manque de profondeur
Une profondeur de 2 est suffisante dans de nombreux cas pour approcher n’importe quelle fonction avec
une précision arbitraire. C’est le cas, par exemple, pour les portes logiques, les neurones formels (à seuil),
les neurones avec une fonction d’activation sigmoïdale, et les unités à base radiale (radial basis function,
RBF) comme dans les SVMs. Mais cette possibilité a un prix : le nombre de nœuds requis dans le graphe
(c’est-à-dire le nombre d’opérations, mais aussi le nombre de paramètres à entraîner) peut devenir très large.
En fait, des résultats théoriques indiquent que, pour certaines familles de fonctions, le nombre de nœuds
nécessaires peut grandir selon l’exponentielle du nombre de dimensions des entrées. Cela a été montré
pour les portes logiques, les neurones formels, ainsi que les neurones à base radiale (RBF). Dans ce dernier
cas, Hastad a montré que certaines familles de fonctions, qui peuvent être représentées efficacement (de
façon compacte) avec O(n) nœuds (pour n entrées) lorsque la profondeur est d, onb besoin d’un nombre
exponentiel de nœuds (O(2n )) lorsque la profondeur est limitées à d − 1.
Une architecture profonde peut être vue comme une forme de factorisation. La plupart des fonctions choisies
au hasard ne peuvent pas être représentées efficacement, que ce soit avec une architecture profonde, ou peu
profonde. En revanche, beaucoup de fonctions qui peuvent être représentées efficacement par une architecture profonde ne peuvent pas l’être avec une architecture peu profonde (voir l’exemple des polynômes dans
l’article de revue de Bengio). L’existence d’une représentation compacte et profonde indique qu’il existe
une certaine structure dans la fonction représentée. Si la fonction n’a pas de structure du tout, il sera de
toutes façons impossible de généraliser.
3.4 Architecture profonde du cerveau
Les nombreuses études du cortex visuel montrent qu’il existe une série d’aires, qui contiennent chacune
une représentation de l’entrée (le champ visuel), et des signaux se propagent d’une aire à la suivante (il y a
aussi des connexions directes entre aires éloignées, et des chemins parallèles, donc la réalité est un peu plus
complexe).
Notons que les représentations dans le cerveau ne sont ni complètement denses et distribuées, ni purement
locales, mais entre les deux : ce sont des représentations éparses (ou clairsemées, sparse). Environ 1 % des
neurones sont actifs simultanément dans le cerveau. Considérant le grand nombre de neurones, cela reste
une représentation (exponentiellement) efficace.
14
Chapter 3. Introduction aux algorithmes d’apprentissage profonds
3.5 Profondeur des processus cognitifs
• Les humains organisent leurs idées et leurs concepts de façon hiérarchique.
• Les humains apprennent d’abord des concepts simples, et les combinent ensuite pour représenter des
concepts plus abstrait.
• Les ingénieurs (généralement humains) construisent des solutions en combinant de nombreux niveaux
d’abstraction et de traitement.
Nous aimerions arriver à apprendre et découvrir ces concepts (peut-être que l’ingénierie des connaissances
n’a pas fonctionné car l’introspection n’était pas adéquate). L’introspection des concepts exprimable par
le langage suggère aussi une représentation éparse: la description d’une entrée donnée (par exemple, une
scène visuelle) fait appel uniquement à une faiblle fraction de tous les mots et concepts existants.
3.6 Partage statistique
Les représentations intermédiaires peuvent être exploitées pour partager la force statistique, en mettant
à contribution différents contextes. Premièrement, si des architectures plus profondes peuvent être plus
efficaces en termes du nombre d’unités de calcul (pour représenter la même fonction), cela signifie en
principe que le nombre de paramètres à estimer est plus petit, ce qui entraîne une plus grande efficacité
statistique.
Une autre façon de comprendre le partage de la force statistique, c’est de considérer ce qui se passe lorsque
différents composants de l’architecture sont réutilisés pour différents usages (par exemple, pour le calcul
de différentes sorties, ou pour différentes tâches, ou pour le calcul de différentes représentations intermédiaires). Comme les paramètres de ce composant sont utilisés dans différents contextes, cela permet d’utiliser
plus d’information (qui vient de plus d’exemples, ou de parties d’exemples) pour estimer ces paramètres,
donc de réduire l’incertitude sur ces paramètres.
Ce partage est similaire à celui qui a lieur dans l’apprentissage de représentations distribuées. Par exemple,
si les paramètres d’une unité cachées d’une RBM sont “utilisés” pour beaucoup d’exemples (parce que cette
unité est activée pour beaucoup d’exemples), alors il existe plus d’information disponible pour estimer ces
paramètres. Lorsqu’une nouvelle configuration des entrées se présente, même si elle ne correspond à aucun
des exemples vus pendant l’entraînement, ses “composantes” (qui peuvent être représentées explicitement,
à un plus haut niveau d’abstraction, dans une couche intermédiaire) peuvent avoir été vues précédemment.
Le partage de la force statistique est une idée fondamentale derrière de nombreuses avances dans
l’apprentissage machine. Des composants et des paramètres sont partagés entre différentes tâches dans
le cas de l’apprentissage multi-tâches (multi-task learning), et les architectures profondes sont particulièrement adaptées pour l’apprentissage multi-tâches (Collobert & Weston, ICML2008). De la même manière,
l’apprentissage semi-supervisé exploite le partage statistique entre les deux tâches suivantes : apprendre la
distribution des entrées P (X), et apprendre la distribution conditionnelle P (Y |X). Comme les algorithmes
d’apprentissage profond reposent souvent sur l’apprentissage non supervisé, ils sont bien positionnés pour
exploiter cette forme particulière de partage statistique.
Une forme voisine de partage est exploitée par l’apprentissage autodidacte (self-taught learning), (Raina et
al, 2007), où l’on utilise pendant l’entraînement des exemples non étiquetés, provenant de P (X|Y ), pour un
ensemble de classes Y donné, mais où le but est de généraliser à de à des tâches P (Y |X) pour un ensemble
3.5. Profondeur des processus cognitifs
15
de tâches Y différentes. Des travaux récents ont montré que des architectures profondes bénéficient plus de
l’apprentissage autodidacte et de l’apprentissage multi-tâches que les architectures peu profondes (Bengio
et al, NIPS 2010 deep learning workshop).
C’est aussi une forme de généralisation hors-domaine (out-of-domain generalization), domaine dans lequel
les architectures profondes sont également appropriées, comme montré dans (Bengio et al, NIPS 2010 deep
learning workshop) en ce qui concerne la reconnaissance de patrons (pattern recognition) et dans (Glorot et
al, 2011) pour le traitement du langage naturel (natural language processing, NLP), plus particulièrement
l’analyse de sentiment.
3.7 Percée dans l’apprentissage des architectures profondes
Avant 2006, les tentatives d’entraîner des architectures profondes avaient échoué : un réseau de neurones
supervisé (non récurrent) profond donnait de moins bons résultats (en erreur d’entraînement et en erreur de
test) que des réseaux moins profonds (1 ou 2 couches cachées).
Trois articles, publiés en 2006, ont changé cela, dans le sillage du travail révolutionnaire de Hinton sur les
deep belief networks (DBNs) :
• Hinton, G. E., Osindero, S. and Teh, Y., A fast learning algorithm for deep belief nets Neural Computation 18:1527-1554, 2006
• Yoshua Bengio, Pascal Lamblin, Dan Popovici and Hugo Larochelle, Greedy Layer-Wise Training of
Deep Networks, in J. Platt et al. (Eds), Advances in Neural Information Processing Systems 19 (NIPS
2006), pp. 153-160, MIT Press, 2007
• Marc’Aurelio Ranzato, Christopher Poultney, Sumit Chopra and Yann LeCun Efficient Learning of
Sparse Representations with an Energy-Based Model, in J. Platt et al. (Eds), Advances in Neural
Information Processing Systems (NIPS 2006), MIT Press, 2007
Les trois principes-clés suivants sont utilisés dans ces trois articles :
• L’apprentissage non supervisé de représentations est utilisé pour pré-entraîner chaque couche.
• L’apprentissage non supervisé se fait une couche à la fois, chaque couche entraînée après la couche
du dessous. La représentation apprise par une couche est utilisée comme entrée par la couche suivante
(du dessus).
• L’apprentissage supervisé est utilisé pour raffiner toutes les couches pré-entraînées (ainsi que la
couche de sortie, et éventuellement d’autres couches supplémentaires).
Les DBNs utilisent des RBMs pour la phase non supervisée (l’apprentissage de représentations à chaque
couche). L’article de Bengio et al. explore et compare des RBMs et des auto-encodeurs (un auto-encodeur
est un réseau de neurones entraîné pour prédire sa propre entrée, en passant par une couche cachée qui sert de
représentation intermédiaire). L’article de Ranzato et al. utilise des auto-encodeurs épars (qui sont similaires
au codage épars (sparse coding) dans le contexte d’une architecture à convolution. Les auto-encodeurs et
les architectures à convolution seront abordés plus tard dans le cours.
Depuis 2006, une pléthore d’autres articles sur le sujet de l’apprentissage profond ont été publiés, certains
exploitant d’autres principes pour guider l’entraînement de représentations intermédiaires. Voir Learning
Deep Architectures for AI pour une revue.
16
English version
3.7. Percée dans l’apprentissage des architectures profondes
17
18
CHAPTER
FOUR
INTRODUCTION À L’APPRENTISSAGE
PAR DESCENTE DE GRADIENT
Considérons une fonction de coût C, qui associe un vecteur de paramètres θ à un scalaire C(θ), que
nous voulons minimiser. En apprentissage machine, la fonction de coût est généralement la moyenne, ou
l’espérance, de la fonction d’erreur L :
n
C(θ) =
1X
L(fθ , zi )
n
i=1
(c’est ce que l’on appelle l’erreur d’entraînement), ou
Z
C(θ) = L(fθ , z)P (z)dz
(c’est l’erreur de généralisation). En apprentissage supervisé, on a z = (x, y), et fθ (x) est une prédiction
de y, indexée par les paramètres θ.
4.1 Le gradient
Le gradient de la fonction C par rapport à un scalaire θ est défini formellement comme suit :
C(θ + δθ) − C(θ)
∂C(θ)
= lim
δθ→0
∂θ
δθ
C’est-à-dire que c’est la variation ∆C provoquée par un changement ∆θ, dans la limite où ∆θ est très petit.
∂C(θ)
Lorsque θ est un vecteur, le gradient ∂C(θ)
∂θ est un vecteur, contenant un élément ∂θi pour chaque θi , en
considérant les autres paramètres fixés : on fait le changement ∆θi , et on mesure le ∆C résultant. Lorsque
∆C
∆θi est petit, alors ∆θ
devient ∂C(θ)
∂θi .
i
19
4.2 Descente de gradient
Nous voulons trouver une valeur de θ qui minimise C(θ). Si nous arrivons à résoudre
∂C(θ)
=0
∂θ
alors nous pouvons trouver les minimums (et les maximums, et les points de selle), mais généralement
nous ne sommes pas capables de trouver les solutions de cette équation, donc nous utilisons des méthodes
numériques d’optimisation. La plupart de ces méthodes reposent sur l’idée de la descente locale : on modifie
itérativement θ pour diminuer C(θ), jusqu’à ce que ça devienne impossible, c’est-à-dire que nous sommes
arrivés à un minimum local (et peut-être global, avec de la chance).
La technique la plus simple, parmi les techniques d’optimisation à base de gradient, est la descente de
gradient. Il existe de nombreuses variantes de descente de gradient, commençons par la descente de gradient
ordinaire :
θk+1 = θk − k
∂C(θk )
∂θk
où θk représente nos paramètres à l’itération k, et k est un scalaire appelé pas de gradient (learning rate),
qui peut être fixé, adaptatif, ou déterminé par un échéancier (schedule).
4.3 Descente de gradient stochastique
Pour la descente de gradient stochastique, nous exploitons le fait que C est une moyenne sur des exemples
généralement i.i.d. (indépendants et identiquement distribués) pour faire des mises à jour de θ de manière
beaucoup plus fréquente, à la limite (et dans le cas le plus commun) après chaque exemple :
θk+1 = θk − k
∂L(θk , z)
∂θk
où z est le prochain exemple dans l’ensemble d’entraînement, ou le prochain exemple tiré de la distribution
d’entraînement dans le cas en ligne (online) (où l’on n’a pas accès à un ensemble d’entraînement de taille
fixe, mais à un flux d’exemples provenant d’un processus de génération de données).
La descente de gradient stochastique (stochastic gradient descent, SGD) est un principe plus général, dans
lequel la direction de la mise à jour est une variable aléatoire, dont l’espérance est le véritable gradient qui
nous intéresse. Les conditions de convergence de la SGD sont similaires à celles de la descente de gradient,
malgré la plus grande quantité de hasard.
La SGD peut être beaucoup plus rapide que la descente de gradient ordinaire (batch), parce que le nombre
de mises à jour est beaucoup plus grand. C’est particulièrement vrai pour des jeux de données volumineux,
ou pour le cas en ligne. En fait, dans les tâches d’apprentissage machine, on n’utilise la descente de gradient
ordinaire (au lieu de stochastique) que lorsque la fonction à minimiser ne peut pas être décomposée comme
ci-dessus (comme une moyenne).
20
Chapter 4. Introduction à l’apprentissage par descente de gradient
4.4 Descente de gradient stochastique par mini-lots
C’est une variante de la SGD, dans laquelle on obtient la direction de la mise à jour en prenant la moyenne de
l’erreur sur un petit nombre d’exemples (mini-lot, ou minibatch) B (par exemple, 10, 20 ou 100). L’avantage
principal est qu’au lieu d’effectuer B produits vecteur-matrice, on peut souvent faire un produit matricematrice, la première matrice ayant B rangées, ce qui peut être implémenté de façon beaucoup plus efficace
(parfois 2 à 10 fois plus rapide, selon la taille des matrices).
La SGD par mini-lots a l’avantage de travailler avec un estimé du gradient qui est moins bruité (de moins
en moins bruité lorsque B augmente). Par contre, lorsque la taille du lot augmente, le nombre de mises à
jour diminue par rapport au nombre de calculs faits (à la limite, cela devient très inefficace, autant que la
descente de gradient ordinaire). Il y a un compromis optimal (en terme d’efficacité computationnelle), qui
peut varier selon la distribution des données et les particularités de la classe de fonctions considérée, ainsi
que de la manière dont les calculs sont réalisés (l’architecture matérielle et le parallélisme peuvent faire une
différence).
4.5 Inertie (momentum)
Une autre variation, dont l’esprit est similaire à celui de la SGD par mini-lots, est l’utilisation d’un terme
dit d’inertie (momentum): l’idée est de calculer à la volée une moyenne mobile des gradients précédents, et
d’utiliser cette moyenne mobile, et non le gradient de l’exemple courant, dans la formule de mise à jour. La
moyenne mobile est généralement une moyenne mobile exponentielle :
∆θk+1 = α∆θk + (1 − α)
∂L(θk , z)
∂θk
où α est un hyper-paramètre contrôlant le poids relatif des gradients plus ancients par rapport aux plus
récents.
4.6 Choisir l’échéancier du pas de gradient
Si le pas de gradient est trop grand – plus grand que le double de la plus grande valeur propre de la dérivée
seconde (hessienne) de C –, alors les mises à jour font augmenter le coût au lieu de le diminuer. Si le pas
de gradient est trop petit, la convergence est plus lente.
Les choix d’échéancier du pas de gradient (k ) sont les suivants:
• Valeur constante, k = 0 : c’est le choix le plus commun. En théorie, il donne un poids exponentiellement plus grand aux exemples les plus récents, et il est particulièrement adapté dans un environnement
non stationnaire, où la distribution peut changer. Il est très robuste, mais l’erreur arrête de diminué
après un certain temps, alors qu’un pas de gradient plus petit pourrait donner une solution plus précise
(s’approcher un peu plus du minimum).
4.4. Descente de gradient stochastique par mini-lots
21
τ
. Il est garanti que cet échéancier arrivera à converger asymptotique• Diminution en 1/k : k = 0 τ +k
ment (lorsque k → ∞), car il satisfait aux conditions suivantes :
∞
X
k = ∞
k=1
∞
X
2k < ∞
k=1
Cette garantie est vraie quel que soit τ , mais 0 doit être assez petit pour éviter de diverger (lorsque
l’erreur augmente au lieu de diminuer).
Un des inconvénients est l’ajout d’un nouvel hyper-paramètre τ . Un autre problème est que, malgré
les garanties, un mauvais choix de τ peut entraîner une convergence très lente.
4.7 Graphes de flot, dérivée en chaîne et rétropropagation : calcul
efficace du gradient
Considérons une fonction (dans notre cas, ce sera L(θ, z)) de plusieurs arguments, nous voulons calculer
sa valeur, ainsi que celle de sa dérivée (son gradient) par rapport à certains de ses arguments. Nous allons
décomposer le calcul de la fonction en termes de calculs élémentaires, pour lesquels les dérivées partielles
sont faciles à calculer, formant ainsi un graphe de flot (comme déjà mentionné ici). Un graphe de flot est
un graphe dirigé acyclique, où chaque nœud représente le résultat d’un calcul qui est effectué sur les valeurs
associées aux nœuds du graphe qui lui sont connectés. Le graphe a des nœuds d’entrée (sans prédécesseurs),
et des nœuds de sortie (sans sucesseurs).
Chaque nœud du graphe de flot est associé à une expression symbolique, qui définit comment sa valeur est
calculée à partir des valeurs de ses enfants (les nœuds qui lui servent d’entrées). Nous nous concentrerons
sur l’utilisation des graphes de flot pour un calcul efficace du gradient, plus particulièrement du gradient
d’un nœud de sortie particulier, scalaire (noté L ici, on s’intéresse au gradient d’une fonction d’erreur par
rapport aux paramètres). À chaque nœud, nous associerons :
• la valeur du nœud,
• l’expression symbolique qui spécifie comment calculer la valeur du nœud à partir des valeurs de ses
prédécesseurs (ses enfants),
• la dérivée partielle de L par rapport à la valeur du nœud,
• l’expression symbolique qui spécifie comment calculer la valeur de cette dérivée partielle, à partir des
valeurs de ses prédécesseurs.
Soit L le nœud de sortie scalaire du graphe de flot, considérons un nœud arbitraire u, dont les parent (les
nœuds qui prennent comme entrée la valeur calculée par u) sont vi . En plus de la valeur u (c’est un abus de
notation) associée au nœud u, nous allons aussi associer à chaque nœud u une dérivée partielle : ∂L
∂u .
22
La règle de dérivation en chaîne spécifie comment la dérivée partielle ∂L
∂u pour un nœud u peut être obtenue,
∂L
de manière récursive, à partir des dérivées partielles ∂v
pour
ses
parents
vi :
i
∂L X ∂L ∂vi
=
∂u
∂vi ∂u
i
Notons que la récursion commence à ∂L
∂L = 1, pour le nœud racine du graphe (dans le cas général, c’est
bien un graphe et non un arbre, car il peut y avoir plusieurs chemins entre un nœud donné et le nœud racine,
i
ou sortie). Notons aussi que chaque ∂v
∂u est une expression (à laquelle correspond une valeur, lorsque les
valeurs d’entrée sont données) associée à un arc du graphe (et chaque arc est associé à une dérivée partielle
de ce type).
On remarque que les calculs de gradient utilisés dans cette méthode vont exactement dans le sens opposé
des calculs utilisés pour calculer L. En fait, on dit que les gradients sont rétropropagés, en suivant les arcs
dans le sens inverse. L’utilisation de cette procédure pour calculer le gradient dans le cas de réseaux de
neurones (sans récurrence) multi-couches est appelée l’algorithme de la rétropropagation du gradient.
Dans l’exemple vu plus tôt, L = sin(a2 + b/a), et il y a deux chemins de a vers L.
Cette méthode nous donne certaines garanties. Si le calcul de L s’exprime par n calculs, matérialisés par
n nœuds (et que le calcul chaque nœud requiert un temps constant) et m arcs, alors le calcul de toutes les
dérivées partielles ∂L
∂u requiert (au plus) O(m) calculs, en utilisant la récursion ci-dessus (en général, le
nombre d’entrées d’un nœud est borné, et c’est aussi O(n)). De plus, c’est aussi une borne inférieure, c’està-dire qu’il n’est pas possible de calculer le gradient plus vite (à une constante additive et multiplicative
près).
Notons enfin qu’il existe de nombreuses manières de calculer ces gradients, et qu’alors que l’algorithme
ci-dessus est le plus rapide, il est facile d’écrire une récursion, apparemment simple, qui serait exponentiellement plus lente, c’est-à-dire en O(2n ). De manière générale, ∂L
∂u peut être écrite comme la somme, sur
tous les chemins du graphe de u à L, du produit des dérivées partielles selon chaque chemin.
Illustrons cela avec un graphe qui a la structure suivante :
xt = f (xt−1 , yt−1 )
yt = g(xt−1 , yt−1 )
où il existe p = n/2 paires de nœuds (xt , yt ), terminant par L
√= nh(xp , yp ), et dont les nœuds d’entrée sont
p
n/2
x0 et y0 . Le nombre de chemins de x0 à L est 2 = 2
= ( 2) . Par construction, à chaque fois que l’on
ajoute une paire de nœuds, le nombre de chemins est doublé.
English version
4.7. Graphes de flot, dérivée en chaîne et rétropropagation : calcul efficace du gradient 23
24
CHAPTER
FIVE
INTRODUCTION AUX PERCEPTRONS
MULTI-COUCHES (RÉSEAUX DE
NEURONES À PROPAGATION AVANT)
On appelle réseau de neurone “à propagation avant” (feedforward neural network) un réseau de neurone
sans connection récurrente.
5.1 Réseaux de neurones multi-couches
Un perceptron multi-couches (PMC, ou multi-layer perceptron, MLP), ou réseau de neurones multi-couches,
définit une famille de fonctions. Considérons d’abord le cas le plus classique, celui d’un réseau de neurones
à une couche cachée, qui associe à un vecteur de dimension d un vecteur de longueur m (par exemple, pour
effectuer une régression) :
g(x) = b + W tanh(c + V x)
où :
• x est un vecteur de longueur d (l’entrée) ;
• V est une matrice k × d (les poids de la couche d’entrée vers la couche cachée) ;
• c est un vecteur de longueur k (les biais de la couche cachée) ;
• b est un vecteur de longueur m (les biais de la couche de sortie) ;
• W est une matrice m × h (les poids de la couche cachée vers la couche de sortie).
La fonction h(x) = tanh(x + V x), qui retourne un vecteur, est appelée la sortie de la couche cachée.
Notons que dans le réseau ci-dessus, la sortie est une transformation affine de la couche cachée. Une nonlinéarité peut être appliquée par dessus dans certaines architectures. Les éléments de la couche cachée sont
appelés unités cachées.
Il est possible d’appliquer à nouveau le même genre de transformation à h(x) elle-même, avec des
paramètres (biais et poids) différents. Cela donnerait un réseau de neurones multi-couches (à propagation avant) avec deux couches cachées. De manière plus générale, on peut construire un réseau de neurones
profond en empilant plusieurs de ces couches. Chacune des couches peut avoir une taille différente (le k
25
utilisé ci-dessus). Une variante commune est l’ajout de connexions directes, c’est-à-dire qu’une couche
peut prendre comme entrée à la fois la couche précédente et d’autres couches plus basses (plus proches de
l’entrée).
5.2 Critères d’entraînements communs et non-linéarités de sortie
Soit f (x) = r(g(x)), où r représente la fonction non-linéaire de sortie. En apprentissage supervisé, la sortie
f (x) peut être comparée avec une valeur cible, y, par une fonction d’erreur, L(f, (x, y)). Voici quelques
fonctions d’erreur utilisées communément, avec la non-linéarité de sortie correspondante :
• Pour une régression
P (L2) ordinaire : pas de non-linéarité (r(a) = a), erreur quadratique L(f, (x, y)) =
kf (x) − yk2 = i (fi (x) − yi )2 .
• Pour une régression
P médiane (L1) : pas de non-linéarité (r(a) = a), erreur absolue : L(f, (x, y)) =
|f (x) − y|1 = i |fi (x) − yi |.
• Pour la classification probabiliste à deux classes : la non-linéarité est la sigmoïde logistique (r(a) =
sigmoid(a) = 1/(1 + e−a ), appliquée élément par élément), et l’erreur est l’entropie croisée (crossentropy) L(f, (x, y)) = −y log f (x) − (1 − y) log(1 − f (x)), pour y binaire. Notons que la sortie de
la sigmoide f (x) est dans l’intervalle (0, 1), et correspond à un estimateur de P (y = 1|x). La classe
1 est prédite si f (x) > 21 .
• Pour la classification binaire multiple : chaque élément du vecteur de sortie est traité comme ci-dessus.
• Pour la classification dure à deux classes, avec l’erreur charnière (hinge loss) : pas de non-linéarité, et
l’erreur charnière est L(f, (x, y)) = max(0, 1−(2y−1)f (x)) (ici aussi, pour y binaire). C’est l’erreur
utilisée par les classifieurs comme les machines à vecteurs de support (support vector machines, SVM).
• Le cas ci-dessus peut être généralisé à des classes multiples, en considérant séparément la classification binaire de chaque classe contre toutes les autres.
• PourP
la classification probabilistique multi-classes : la non-linéarité est le softmax (ri (a) =
eai / j eaj , avec une sortie
P par classe), l’erreur est la log-vraisemblance négative, L(f, (x, y)) =
− log fy (x). Notons que i fi (x) = 1 et que 0 < fi (x) < 1. Notons aussi que c’est équivalent à
l’entropie croisée dans le cas de 2 classes (la sortie pour la deuxième classe est en faite redondante).
5.3 L’algorithme de rétropropagation
Il s’agit simplement d’appliquer l’algorithme récursif de calcul du gradient, vu précédemment, au graphe
formé par le PMC, avec un nœud par unité d’entrée, par unité cachée, et par unité de sortie. Notons que
chaque paramètre (biais ou poids) correspond aussi à un nœud.
Voici quelques conventions de notation pour les PMC avec plus d’une couche cachée. On note hi le vecteur
de sortie de la couche i, en commençant par h0 (x) = x (l’entrée), jusqu’à la couche de sortie, hK , qui
produit la prédiction, ou sortie, du réseau.
Avec des unités tanh (dont la fonction d’activation est la tangente hyperbolique) dans les couches cachées,
nous avons (en utilisant la notation matricielle) :
• Pour k = 1 à K − 1:
26
Chapter 5. Introduction aux perceptrons multi-couches (réseaux de neurones à
propagation avant)
– hk = tanh(bk + Wk hk−1 )
où bk est un vecteur de biais, et Wk est une matrice de poids, connectant la couche k − 1 à la
couche
k. Le calcul scalaire associé à une unité donnée i de la couche k est hk,i = tanh(bk,i +
P
W
k,i,j hk−1,j ).
j
Dans le cas d’un classifieur probabiliste, nous avons un softmax sur la couche de sortie, c’est-à-dire :
p = hK = softmax(bK + WK hK−1 )
où nous notons la sortie p parce que c’est un vecteur indiquant une distribution de probabilité sur les classes.
L’erreur est
L = − log py
où y est la classe cible, c’est-à-dire que l’on veut maximiser py = P (Y = y|x), qui est un estimateur de la
probabilité conditionnelle de la classe y étant donnée l’entrée x.
Voyons maintenant comment se fait, dans cette structure, l’application récursive de la règle de dérivation en
chaîne dans un graphe de flot. Soit
ak = bk + Wk hk−1
l’argument de la non-linéarité à chaque couche, que nous appellerons le potentiel, notons que (par une
dérivation rapide)
∂(− log py )
= (pi − 1y=i )
∂aK,i
et que
∂ tanh(u)
= (1 − tanh(u)2 ).
∂u
Maintenant, appliquons la méthode de la rétropropagation dans le graphe de flot correspondant. Chaque
paramètre (chaque poids et chaque biais) est un nœud, le potentiel ak,i et la sortie hk,i de chaque neurone
est aussi un nœud.
• On part du nœud de sortie:
∂L
=1
∂L
• Ensuite, on calcule le gradient de L par rapport à chacune des sommes précédant le softmax, aK,i :
∂L
∂L ∂L
=
= (pi − 1y=i ).
∂aK,i
∂L ∂aK,i
5.3. L’algorithme de rétropropagation
27
• Maintenant, on peut répéter la procédure pour chaque couche. Pour k = K descendant jusqu’à 1 :
– On obtient facilement le gradient de L par rapport aux biais :
∂L
∂L ∂ak,i
∂L
=
=
.
∂bk,i
∂ak,i ∂bk,i
∂ak,i
– On calcule le gradient par rapport aux poids :
∂L ∂ak,i
∂L
∂L
=
=
hk−1,j .
∂Wk,i,j
∂ak,i ∂Wk,i,j
∂ak,i
– On rétropropage le gradient vers la couche précédente, si k > 1 :
X ∂L ∂ak,i
X ∂L
∂L
=
=
Wk,i,j
∂hk−1,j
∂ak,i ∂hk−1,j
∂ak,i
i
i
∂L
∂L ∂hk−1,j
∂L
=
=
(1 − h2k−1,j )
∂ak−1,j
∂hk−1,j ∂ak−1,j
∂hk−1,j
5.4 Régression logistique
La régression logistique est un cas particulier de PMC, qui n’a pas de couche cachée (l’entrée est directement
connectée à la sortie), dont l’erreur est l’entropie croisée (sortie sigmoïde), ou la log-vraisemblance négative
(sortie softmax). C’est un classifieur linéaire probabiliste, et le critère d’entraînement est convexe selon les
paramètres (ce qui garantit qu’il existe un seul minimum, global).
28
Chapter 5. Introduction aux perceptrons multi-couches (réseaux de neurones à
propagation avant)
CHAPTER
SIX
L’ENTRAÎNEMENT DE RÉSEAUX DE
NEURONES MULTI-COUCHES
De nombreux algorithmes pour entraîner des réseaux de neurones multi-couches ont été proposés, mais les
plus couramment utilisés sont à base de gradient.
Deux principes fondamentaux guident les différentes stratégies employées pour entraîner des PMC :
• Entraîner aussi efficacement que possible, c’est-à-dire faire baisser l’erreur d’entraînement aussi vite
que possible, éviter d’être bloqué dans une vallée étroite ou un minimum local de la fonction de coût ;
• Contrôler la capacité, de manière à éviter le sur-apprentissage, afin de minimiser l’erreur de généralisation.
6.1 Problème fondamentalement difficile d’optimisation
L’optimisation du critère d’apprentissage dans les réseaux de neurones multi-couches est difficile car il y
a de nombreux minima locaux. On peut même démontrer que de trouver les poids optimaux est NP-dur.
Cependant on se contente de trouver un bon minimum local, ou même simplement une valeur suffisamment
basse du critère. Comme ce qui nous intéresse est la généralisation et non pas l’erreur d’apprentissage (ce
qu’on minimise n’est pas ce qu’on voudrait vraiment minimiser), la différence entre “près d’un minimum”
et “au minimum” est souvent sans importance. Par ailleurs, comme il n’y a pas de solution analytique au
problème de minimisation, on est forcé de faire cette optimisation de manière itérative.
6.2 Choix de l’architecture
En principe, une manière d’accélérer la descente de gradient est de faire des choix qui rendent la matrice
2C
Hessienne ∂θ∂i ∂θ
mieux conditionnée. La dérivée seconde dans une certaine direction indique la courbure
j
de la fonction de coût dans cette direction. Plus la courbure est grande (vallée étroite) et plus petites doivent
être les mises à jour des paramètres si on éviter que l’erreur augmente. Plus précisement, le pas de gradient
optimal est 1 sur la courbure. On peut voir cela par une simple expansion de Taylor du coût et est derrière
le fameux algorithme de Newton pour l’optimisation. Mettons que l’on soit à θk et que l’on veuille choisir
29
θk+1 pour qu’il soit un minimum:
C(θk+1 ) = C(θk ) + (θk+1 − θk )C 0 (θk ) + 0.5(θk+1 − θk )2 C 00 (θk )
0=
∂C(θk+1 )
= C 0 (θk ) + (θk+1 − θk )C 00 (θk )
∂θk+1
C 0 (θk )
θk+1 = θk − 00 k
C (θ )
Donc on veut un pas de gradient égal à l’inverse de la dérivée seconde. On peut montrer que le nombre
d’itération d’un algorithme de descente de gradient sera proportionnel au ratio de la plus grande à la plus
petite valeur propre de la matrice Hessienne (avec une approximation quadratique de la fonction de coût).
La raison de base en est que la plus grande valeur propre limite le pas de gradient maximum (on ne peut
aller plus vite que la courbure la plus forte parmi toutes les directions possibles, sinon l’erreur remonte),
mais qu’en utilisant le même pas de gradient dans toutes les directions, la convergence sera la plus longue
dans la direction la plus “plate” (valeur propre la plus petite).
• En théorie une couche cachée suffit, mais cette théorie ne dit pas que cette représentation de la fonction
sera efficace. En pratique cela a été le choix le plus commun avant 2006, sauf pour les réseaux de
neurones à convolution (qui peuvent avoir 5 ou 6 couches par exemple). Parfois on obtient de bien
meilleurs résultats avec 2 couches cachées. En fait on peut obtenir une bien meilleure généralisation
avec encore plus de couches, mais une initialisation aléatoire ne fonctionne pas bien avec plus de
deux couches (mais voir les travaux depuis 2006 sur l’initialisation non-supervisée vorace pour les
architectures profondes).
• Pour la régression ou avec des cibles réelles et non-bornées en général, il vaut généralement mieux
utiliser des neurones linéaires à la couche de sortie. Pour la classification, il vaut généralement mieux
utiliser des neurones avec non-linéralité (sigmoide ou softmax) à la couche de sortie.
• Dans certains cas une connexion directe entre l’entrée et la sortie peut être utile. Dans le cas de
la régression, elle peut aussi être initialisée directement par le résultat d’une régression linéaire des
sorties sur les entrées. Les neurones cachées servent alors seulement à apprendre la partie non-linéaire
manquante.
• Une architecture avec poids partagés, ou bien le partage de certains éléments de l’architecture (e.g.,
la première couche) entre les réseaux associés à plusieurs tâches connexes, peuvent significativement
améliorer la généralisation. Voir aussi la discussion à venir sur les réseaux à convolution.
• Il vaut mieux utiliser une non-linéarité symétrique dans les couches cachées (comme la tanh, et non
pas la sigmoide), afin d’améliorer le conditionnement du Hessien et éviter la saturation des couches
cachées.
6.3 Normalisation des entrées
Il est impératif que les entrées soient de moyenne pas trop loin de zéro et de variance pas trop loin de 1.
Les valeurs en entrées devraient aussi ne pas avoir une magnitude trop grande. On peut faire certaines
transformations monotones non-linéaires qui réduisent les grandes valeurs. Si on a une entrée très grande,
elle fait saturer plusieurs neurones et bloque l’apprentissage pour cet exemple. Les magnitudes (variances)
des entrées de chaque couche devraient aussi être du même ordre quand on utilise un pas de gradient commun
pour toute les couches, pour éviter que l’une des couches devienne le goulot d’étranglement (plus lent à
30
Chapter 6. L’entraînement de réseaux de neurones multi-couches
entraîner). En fait, dans le cas linéaire, le conditionnement du Hessien est optimal quand les entrées sont
normalisées (donc avec matrice de covariance = identité), ce qui peut se faire en les projetant dans l’espace
des vecteurs propres de la matrice X 0 X, où X est la matrice de dimension nombre d’exemples par nombre
d’entrées.
6.4 Traitement des sorties désirées
Dans le cas d’apprentissage par minimisation d’un coût quadratique, on doit s’assurer que les sorties désirées
• sont toujours dans l’intervalle des valeurs que la non-linéarité de la couche de sortie peut produire (et
sont à peu près normales N(0,1) dans le cas linéaire),
• ne sont pas trop proches des valeurs limites de la non-linéarité de la couche de sortie: pour la classification, une valeur optimale est près d’un des deux points d’inflexion (i.e., les points de courbure
(dérivée seconde) maximale, environ -0.6 et 0.6 pour tanh, 0.2 et 0.8 pour la sigmoide).
• Il vaut mieux utiliser le critère d’entropie croisée (ou la vraisemblance conditionnelle) pour la classification probabiliste, ou bien le critère de marge “hinge” (comme pour le perceptron et les SVMs,
mais en pénalisant les écarts à la surface de décision au-delà d’une marge). Dans le cas multiclasse,
ça donne
X
(−11y=i fi (x) + 1)+ ,
i
où x+ = x1x>0 est la partie positive et fi (x) est la sortie (sans non-linéarité) pour la classe i.
6.5 Codage des sorties désirées et des entrées discrètes
En entrée comme en sortie, on va généralement représenter les variables discrètes par des groupes d’unités
(un groupe de k unités par variable discrète pouvant prendre k valeurs). L’exception pratique est le cas d’une
variable binaire, qu’on encode généralement avec une seule unité. Dans le cas des sorties on va associer à
chaque groupe une distribution discrète (binomiale pour un seul bit, multinomiale pour une variable discrète
générale).
6.6 Algorithme d’optimisation
Quand le nombre d’exemples est grand (plusieurs milliers) la descente de gradient stochastique est souvent
le meilleur choix (surtout pour la classification), en terme de vitesse et en terme de contrôle de la capacité:
il est plus difficile d’avoir de l’overfitting avec la descente de gradient stochastique. En effet, la descente de
gradient stochastique ne tombe pas facilement dans les minima très pointus (qui ne généralisent pas bien, car
une légére perturbation des données déplaçant la surface d’erreur donnerait une très mauvaise performance),
à cause du bruit induit par le pas de gradient et le gradient “bruité”. Ce gradient bruité aide aussi à sortir de
certains minima locaux, pour la même raison.
6.4. Traitement des sorties désirées
31
Quand la descente de gradient stochastique est utilisée, il est IMPÉRATIF que les exemples soient bien
mélangés: par exemple si on a beaucoup d’exemples consécutifs de la même classe, la convergence sera
très lente. Il suffit de permuter aléatoirement les exemples une fois pour toute, pour éliminer toute dépendence entre les exemples successifs. Avec certaines architectures qui captent des dépendences temporelles
(signaux, musique, parole, séries chrono, vidéo) on a pas le choix de présenter des séquences dont les éléments sont fortement dépendents, mais on peut mélanger les séquences (l’ensemble d’apprentissage est une
suite de séquences).
En principe le pas de gradient devrait être graduellement réduit pendant l’apprentissage pour garantir la
convergence asymptotique. Pour certains problèmes (surtout de classification) cela ne semble pas nécessaire,
0 τ
et peut même nuire. Une cédule de descente raisonnable est par exemple t = t+τ
comme discuté ici. Si on
1
pouvait le calculer, le pas de gradient optimal serait λmax , i.e., l’inverse de la valeur propre la plus grande
de la matrice Hessienne, et le pas de gradient maximal (avant divergence) est deux fois plus grand. Le Cun
propose une méthode pour estimer efficacemenet λmax (voir son tutorial sur le sujet), mais cette technique
ne semble pas courramment utilisée.
Quand le nombre d’exemples (et donc de paramètres) est plus petit, et surtout pour la régression, les techniques du second degré (surtout la technique des gradients conjugués) permettent une convergence beaucoup plus rapide. Ces techniques sont batch (modification des paramètres après calcul de l’erreur et gradient
sur tous les exemples). Ces techniques sont généralement plus facile à ajuster que la descente de gradient
stochastique (moins d’hyper-paramètres ou moins nécessaire de les ajuster par rapport à une valeur par
défaut), mais la généralisation est parfois moins bonne à cause de la facilité de tomber dans des minima
pointus.
Jusqu’à quelques dizaines de milliers d’exemples, la descente de gradient conjugués reste une des meilleures
techniques pour l’optimisation des réseaux de neurones. Au-delà il vaut généralement mieux s’en tenir au
gradient stochastique ou à sa version minibatch.
6.7 Initialisation des paramètres
On ne peut initialiser tous les poids à zéro sans quoi tous les neurones cachés sont condamnés à toujours
faire la même chose (qu’on peut voir par un simple argument de symétrie). On veut aussi éviter la saturation
des neurones (sortie près des limites de la non-linéarité, donc gradient presque 0), mais ne pas être trop près
initialement d’une fonction linéaire. Quand les paramètres sont tous près de 0, le réseau multicouche calcule
une transformation affine (linéaire), donc sa capacité effective par sortie est égale au nombre d’entrées plus
1. En se basant sur ces considérations, le point idéal d’opération du neurone devrait être proche du point
d’inflexion de la non-linéarité (entre la partie linéaire près de l’origine et la partie saturation). Par ailleurs, on
aimerait que la variance moyenne des valeurs des unités cachées soit préservée quand on propage les “activations” de l’entrée vers la sortie, et de la même manière on aimerait que la variance des gradients le soit aussi
quand on les propage de la sortie vers l’entrée. Pour atteindre cet objectif, on
ppeut argumenter
p que les poids
initiaux devraient être initialisés de manière uniforme dans un intervalle [− 6/(ni + no ), 6/(ni + no )],
où ni est le fan-in, i.e., le nombre d’entrées du neurone, le nombre de neurones de la couche précédente, et
no est le fan-out, i.e., le nombre de neurones de la couche visée. Cela suppose que les entrées sont approximativement uniformes dans l’intervalle (-1,1) (et remarquez comme les sorties des unités cachées tanh sont
aussi dans le même intervalle).
32
6.8 Contrôle de la saturation
Un des problèmes fréquents pendant l’apprentissage est la saturation des neurones, souvent dûe à une mauvaise normalisation des entrées ou des sorties désirées ou une mauvaise initialisation des poids, ou bien
à l’utilisation de la sigmoide plutôt qu’une fonction de non-linéarité symétrique comme la tanh. On peut
contrôler cela on observant la distribution des sorties des neurones (en particulier, la moyenne des valeurs absolues de la somme pondérée est un bon indice). Quand les neurones saturent fréquemment, l’apprentissage
est bloqué sur un plateau de la fonction de coût dû à de très petits gradients sur certains paramètres (donc un
très mauvais conditionnement du Hessien).
6.9 Contrôle de la capacité effective
La théorie du structural risk minimization de Vapnik nous dit qu’il existe une capacité optimale autour
de laquelle l’erreur de généralisation augmente (c’est un minimum global et unique). Les techniques de
contrôle de la capacité effective visent donc à chercher ce minimum (evidemment de façon approximative).
• early stopping: il s’agit d’une des techniques les plus populaires et les plus efficaces, mais elle
ne marche pas bien quand le nombre d’exemples disponibles est très petit. L’idée est très simple:
on utilise un ensemble d’exemples de validation non-utilisés pour l’apprentissage par descente de
gradient pour estimer l’erreur de généralisation au fur et à mesure que l’apprentissage itératif progresse (normalement, après chaque époque on mesure l’erreur sur l’ensemble de validation). On
garde les paramètres correspondant au minimum de cette courbe d’erreur de généralisation estimée
(et on peut s’arrêter quand cette erreur commence à remonter sérieusement ou qu’un minimum a été
atteint depuis un certain nombre d’époques). Cela a l’avantage de répondre à une des questions difficile de l’optimisation, qui est: quand arrêter? De plus on remarque qu’on a ainsi choisi pour pas
cher (en temps de calcul) un hyper-paramètre important (le nombre d’itérations d’entraînement) qui
touche à la fois l’optimisation et la généralisation.
• contrôle du nombre d’unités cachées: ce nombre influence directement la capacité. Dans ce cas
il faut malheureusement faire plusieurs d’expériences d’apprentissage, à moins d’utiliser un algorithme d’apprentissage constructif (qui rajoute des ressources au fur et à mesure), voir l’algorithme
de cascade-correlation (Fahlman, 1990). On peut utiliser un ensemble de validation ou la validation croisée pour estimer l’erreur de généralisation. Il faut faire attention au fait que cet estimé est
bruité (d’autant plus qu’il y a peu d’exemples de validation). Quand on a plusieurs couches cachées,
choisir le même nombre d’unités par couche semble bien fonctionner. Le prix à payer pour un nombre
d’unités trop grand est surtout que les calculs sont plus longs, car le nombre accru de paramètre est
généralement compensé par le early stopping. Par contre quand le nombre d’unités cachées est trop
petit, l’effet sur l’erreur de généralisation et sur l’erreur d’apprentissage peut être beaucoup plus grand.
On va généralement choisir la taille des réseau de façon empirique, en gardant ces considérations à
l’esprit pour éviter d’avoir à essayer trop de valeurs de la taille.
• weight decay: c’est une méthode de régularisation (pour contrôler la capacité, empêcher l’overfitting)
dont le but est de pénaliser les poids forts. En effet, on peut montrer que la capacité est bornée par la
magnitude des poids du réseau de neurones. On rajoute la pénalité
X
λ
θi2
i
6.8. Contrôle de la saturation
33
à la fonction de coût. On l’appelle régularisation L2 car on minimise la norme 2 des paramètres.
Certains l’appliquent uniquement aux poids et non pas au biais.
Comme dans le cas précédent, il faut faire plusieurs expériences d’apprentissage et choisir le facteur
de pénalité λ (un hyper-paramètre) qui minimise l’erreur de généralisation estimée. On l’estime
avec un ensemble de validation ou bien par validation croisée.
Une forme de régularisation de plus en plus utilisée comme alternative à la régularisation L2 est
la régularisation L1, qui a comme avantage que les petits paramètres seront carrément amenés à 0,
donnant lieu à un vecteur de paramètres qui est sparse. On va donc minimiser la somme des valeurs
absolues des paramètres.
34
CHAPTER
SEVEN
LE DÉFI D’ENTRAÎNER DES RÉSEAUX
DE NEURONES PROFONDS
Ceci est un résumé de la section 4.2 de Learning Deep Architectures for AI.
• Plusieurs résultats expérimentaux confirment que l’entraînement de réseaux de neurones (supervisés,
initialisation aléatoire) est plus difficile quand ils sont profonds (3, 4 ou 5 couches cachées) que pas
profonds (1 ou 2 couche cachée). Voir Why Does Unsupervised Pre-training Help Deep Learning?.
L’erreur de généralisation est toujours pire, mais l’erreur d’apprentissage peut être pire ou meilleure.
Cela explique sans doute l’absence des architectures profondes dans la littérature scientifique avant
2006 (sauf pour les réseaux à convolution).
• Explications proposées:
– L’entraînement est coïncé dans des minima locaux, des plateaux, (ou bien sortir de l’apparent
minimum nécessiterait de passer par des zones de courbure trop élevée, où il faudrait un pas de
gradient minuscule pendant très longtemps pour en sortir).
– Plus le réseau est profond, plus le degré de non-linéarité du réseau augmente, ce qui augmenterait
les chances de trouver ces obstacles à l’optimisation.
– On peut plus facilement optimiser les couches près de la sortie, donc les couches inférieures
restent avec des transformations pas très utiles de l’entrée; le gradient se propage ‘mal’ en
descendant les couches, peut-être trop diffusé pour être utile pour guider l’apprentissage des
couches inférieures. Cela est confirmé par le succès des algorithmes comme celui de Weston et al (ICML 2008) qui guident une ou plusieurs couches intermédiaires par un algorithme d’apprentissage non-supervisé. L’hypothèse de diffusion du gradient est cohérente avec
l’observation qu’il est possible d’entraîner avec succès des réseaux à convolution profonds.
• L’avantage pour les réseaux profonds de faire un pré-entraînement non-supervisé est clair. Quelles en
sont les raisons? C’est l’objet principal de Why Does Unsupervised Pre-training Help Deep Learning?
et aussi de la section 4.2 de Learning Deep Architectures for AI. En voici les explications proposées
et les conclusions expérimentales principales:
– L’entraînement non-supervisé utilisé est local à chaque couche (pas besoin d’une optimisation
qui coordonne toutes les couches). Ainsi on remarque qu’une machine de Boltzmann profonde
et un auto-encodeur profond ne fonctionne pas bien non plus si ils ne sont pas pré-entraînés avec
des RBMs (apprentissage local à chaque couche).
35
– Le pré-entraînement non-supervisé se comporte comme un régulariseur, qui favorise les poids
des couches inférieures qui sont cohérentes avec un bon modèle de la distribution des entrées,
P (x). Il peut nuire si on a pas assez d’unités cachées. L’a priori exploité est que les transformations des entrées qui sont bonnes pour P (x) sont proches de transformations qui sont bonnes
pour P (y|x). Cet a priori est similaire à celui utilisé en apprentissage semi-supervisé (d’un lien
entre P (y|x) et P (x) vues comme des fonctions de x).
– Il semble que le pré-entraînement non-supervisé initialise l’apprentissage supervisé dans une
bonne région de l’espace des paramètres, à partir de laquelle une descente locale trouve une
meilleure solution que celles trouvées à partir d’initialisation aléatoire. Les régions explorées
pendant l’apprentissage supervisé sont très différentes selon que l’on initialise aléatoirement ou
par pré-entraînement non-supervisé.
– Un pré-entraînement supervisé aide mais pas autant qu’un pré-entraînement non-supervisé, peutêtre parce qu’il est trop vorace (élimine des projections qui seront seulement utile dans le contexte d’une architecture plus profonde) et qu’il n’exploite pas l’a priori du pré-entraînement
non-supervisé.
– Contrairement aux régulariseurs habituels, l’effet du pré-entraînement non-supervisé ne disparaît pas quand le nombre d’exemples devient grand, à cause de son lien avec l’optimisation
non-convexe (même avec beaucoup d’exemples, l’apprentissage avec initialisation aléatoire
reste dans une région moins intéressante, minimum local).
– On a pas un problème d’optimisation au sens habituel du terme parce qu’on peut réduire l’erreur
d’apprentissage (et même l’amener à 0 avec suffisamment d’unités cachées dans les couches de
sortie) en optimisant bien les dernières couches, mais pour bien généraliser, il faut aussi que les
couches inférieures soient bien entraînées (à capter des caractéristiques pertinentes des entrées).
– Il faut plus d’unités cachées quand on utilise le pré-entraînement non-supervisé, peut-être parce
que la plupart des unités cachées apprises par entraînement non-supervisé apprennent des fonctions qui ne sont pas très pertinentes à la classification, alors que certaines sont très utiles (plus
utiles que celles obtenues par initialisation aléatoires).
English version
36
Chapter 7. Le défi d’entraîner des réseaux de neurones profonds
CHAPTER
EIGHT
AUTO-ENCODEURS DÉBRUITANTS VS
AUTO-ENCODEURS ORDINAIRES
Un auto-encodeur débruitant est comme un auto-encodeur, à la différence que pendant l’apprentissage,
l’entrée vue par l’auto-encodeur n’est pas l’entrée brute mais une version stochastiquement corrompue.
L’auto-encodeur débruitant est donc entraîné à reconstruire l’entrée originale à partir de la version bruitée.
Voir l’article d’ICML 2008: Denoising Auto-Encoders.
Différences principales entre les auto-encodeurs ordinaires et les auto-encodeurs débruitants:
Aspect
ce que ça fait
critère
d’apprentissage
nombre d’unités
cachées
choix de la
capacité (nombre
d’unités cachées)
choix du nombre
d’itérations
d’apprentissage
choix de la
quantité de
corruption des
entrées
Table 8.1: Comparaison des auto-encodeurs ordinaires et débruitants
Auto-encodeurs ordinaires
Auto-encodeurs débruitants
trouver une représentation compacte
capter la distribution jointe des entrées
déterministe
stochastique
on doit le limiter pour éviter
d’apprendre l’identité
impossible à partir du critère d’erreur
de reconstruction, car toujours plus
basse avec plus d’unités
impossible à partir de l’erreur de
reconstruction: utiliser l’erreur
classification après ajustement
supervisé
non-applicable
on peut avoir autant d’unités cachées que
nécessaire pour capter la distribution
on peut utiliser la moyenne de l’erreur
de reconstruction
on peut faire du early stopping sur
l’erreur de reconstruction moyenne
on ne peut pas utiliser l’erreur de
reconstruction: utiliser l’erreur de
classification après ajustement supervisé
Article plus complet sur les DAE avec une longue série d’expériences:
Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio and Pierre-Antoine Manzagol,
Stacked Denoising Autoencoders: Learning Useful Representations in a Deep Network with a
Local Denoising Criterion (2010), in: Journal of Machine Learning Research, 11:3371–3408
http://www.iro.umontreal.ca/~lisa/publications2/index.php/publications/show/474
English version
37
38
Chapter 8. Auto-encodeurs débruitants vs auto-encodeurs ordinaires
CHAPTER
NINE
MODÈLES PROBABILISTES POUR LES
ARCHITECTURES PROFONDES
On s’intéresse particulièrement au modèle de la machine de Boltzmann, dont certaines variantes sont utilisées dans des architectures profondes comme les Deep Belief Networks et les Deep Boltzmann Machines.
Voir la section 5 de Learning Deep Architectures for AI.
La distribution de Boltzmann est généralement sur des variables binaires xi ∈ {0, 1}, avec
0
0
ex W x+b x
0
0
x̃ x̃ W x̃ + b x̃
P (x) = P
P
où le dénominateur est simplement un facteur de normalisation pour que x P (x) = 1, et les Wij indiquent
la nature de l’interaction (e.g. positive = xi et xj veulent prendre la même valeur) entre les paires de
variables, et bi indique la propension de xi à prendre la valeur 1.
9.1 Rappels sur les modèles graphiques probabilistes
Voir
Graphical models: probabilistic inference. M. I. Jordan and Y. Weiss. In M. Arbib (Ed.), The Handbook of
Brain Theory and Neural Networks, 2nd edition. Cambridge, MA: MIT Press, 2002.
On peut écrire certaines distributions P (x) pour un vecteur de variables x = (x1 , x2 , . . .) sous la forme
P (x) =
1 Y
ψc (xc )
Z c
où Z est le facteur de normalisation (appelée fonction de partition), et le produit est sur des cliques (des
sous-ensembles xc des éléments du vecteur x), et les ψc (.) sont des fonctions (une par clique) qui indiquent
comment intéragissent les variables de chaque clique.
Un cas particulier où Z peut-être simplifié un peu (factorisé sur les cliques) est celui des modèles dirigés
où les variables sont structurées dans un graphe dirigé acyclique, avec un ordre topologique associant un
39
ensemble de parents parents(xi ) à chaque variable xi :
Y
P (x) =
Pi (xi |parents(xi ))
i
où donc on voit qu’il y a une clique pour chaque variable et ses parents, i.e., Pi (xi |parents(xi )) =
ψi (xi , parents(xi ))/Zi .
Dans le cas général (représenté avec un graphe non-dirigé), les fonctions de potentiel ψc sont directement paramétrisées, souvent dans l’espace du logarithme de ψc , ce qui donne lieu à la formulation appelée
champs aléatoire de Markov:
P (x) =
1 − Pc Ec (xc )
e
Z
P
où E(x) = c Ec (xc ), comme fonction de x, est appelée fonction d’énergie. La fonction d’énergie de la
machine de Boltzmann est donc un polynôme du second degré en x. La paramétrisation la plus commune
des champs aléatoires de Markov a la forme suivante, qui est log-linéaire:
P (x) =
1 − Pc θc fc (xc )
e
Z
où les seuls paramètres libres sont les θc , et où donc la log-vraisemblance complète (quand x est complètement observé dans chaque exemple) est log-linéaire en les paramètres θ, et on peut facilement montrer
qu’elle est convexe en θ.
9.2 Inférence
Un des obstacles les plus importants à l’application pratique de la plupart des modèles probabilistes est
l’inférence: étant données certaines variables (un sous-ensemble de x), prédire la distribution marginale
(chacune séparément) ou jointe de certaines autres. Soit x = (v, h) avec h (hidden) les variables nonobservées que l’on veut prédire, et v (visible) la partie observée. On voudrait calculer ou tout au moins
échantillonner de
P (h|v).
L’inférence est évidemment utile si certaines des variables sont manquantes, ou simplement si pendant
l’utilisation du modèle, on veuille prédire une variable (par exemple la classe de l’image) étant donnée
d’autres (par exemple l’image). Notons que si le modèle a des variables cachées (jamais observées dans les
données) qu’on ne cherche pas à prédire directement, on devra quand même implicitement marginaliser sur
ces variables (sommer sur toutes les configurations de ces variables).
L’inférence est aussi une composante essentielle de l’apprentissage, soit pour calculer un gradient directement (voir ci-bas le cas de la machine de Boltzmann), soit parce qu’on utilise l’algorithme E-M
(Expectation-Maximization), qui requière une marginalisation sur toutes les variables cachées.
40
Chapter 9. Modèles probabilistes pour les architectures profondes
En général, l’inférence exacte a un coût de calcul exponentiel dans la taille des cliques du graphe (en fait
de la partie non-observée du graphe), car on doit considérer toutes les combinaisons possibles des valeurs
des variables dans chaque clique. Voir la section 3.4 de Graphical models: probabilistic inference pour un
survol des méthodes exactes d’inférence.
Une forme simplifiée d’inférence consiste à trouver non pas toute la distribution mais seulement le mode (la
configuation de valeurs la plus probable) de la distribution:
h∗ = argmaxh P (h|v)
En anglais on appelle cela l’inférence MAP = Maximum A Posteriori.
9.3 Inférence approximative
Les deux familles principales d’inférence approximative pour les modèles probabilistes sont l’inférence par
MCMC (chaîne de Markov Monte-Carlo) et l’inférence variationnelle.
Le principe de l’inférence variationnelle est le suivant. On va définir un modèle plus simple que le modèle
cible (celui qui nous intéresse), dans lequel l’inférence sera facile, avec un jeu de variables semblables
(mais généralement avec des dépendances plus simples entre elles que dans le modèle cible). On va ensuite
optimiser les paramètres du modèle simple de façon à ce qu’il s’approche le plus possible du modèle cible.
On va finalement faire l’inférence en utilisant le modèle simple. Voir la section 4.2 de Graphical models:
probabilistic inference pour plus de détails et un survol.
9.4 Inférence par MCMC
En général, la loi P (h|v) peut être exponentiellement chère à représenter (en terme du nombre de variables
cachées, car il faut considérer toutes les configurations des h). Le principe de l’inférence par Monte-Carlo est
que l’on va approximer la distribution P (h|v) par des échantillons tirés de cette loi. En effet, en pratique on a
seulement besoin de faire une espérance (par exemple l’espérance du gradient) sous cette loi conditionnelle.
On va donc remplacer l’espérance recherchée par une moyenne sur ces échantillons. Voir la page du site du
zéro sur Monte-Carlo pour une introduction en douceur.
Malheureusement, pour la plupart des modèles probabilistes, même tirer de P (h|v) de manière exacte n’est
pas faisable facilement (en un temps de calcul qui n’est pas exponentiel dans la dimension de h). C’est
pourquoi l’approche la plus générale est basée sur une approximation de l’échantillonage Monte-Carlo,
appelé Chaîne de Markov Monte-Carlo (MCMC en anglais).
Une chaîne de Markov (d’ordre 1) est une suite de variables aléatoires Z1 , Z2 , . . ., telle que Zk est indépendente de Zk−2 , Zk−3 , . . . étant donnée Zk−1 :
P (Zk |Zk−1 , Zk−2 , Zk−3 , . . .) = P (Zk |Zk−1 )
n
Y
P (Z1 . . . Zn ) = P (Z1 )
P (Zk |Zk−1 )
k=2
Le principe du tirage MCMC est que l’on va construire une chaîne de Markov dont la distribution marginale
asymptotique, i.e., la loi de Zn , quand n → ∞, converge vers une distribution cible, telle que P (h|v) ou
P (x).
9.3. Inférence approximative
41
9.5 Échantillonage de Gibbs
Il existe de nombreuses méthodes d’échantillonage MCMC. Celle la plus couramment utilisée pour les
architectures profondes est la méthode d’échantillonage de Gibbs (Gibbs sampling). Elle est simple et
présente une certaine analogie avec le fonctionnement plausible du cerveau, où chaque neurone décide
d’envoyer des impulsions avec un certain aléa, en fonction des impulsions qu’il reçoit d’autres neurones.
Supposons que l’on veuille échantillonner de la loi P (x) où x est un groupe de variables xi (et optionnellement on pourrait avoir des variables conditionnantes, mais elles ne changent rien à la procédure à part de conditionner tout, donc nous les ignorons dans la notation ici). On notera x−i =
(x1 , x2 , . . . , xi−1 , xi+1 , . . . , xn ), soit toutes les variables de x sauf xi . L’échantillonage de Gibbs ordinaire
est donné par l’algorithme suivant:
• Choisir un x initial de manière arbitraire (aléatoire ou pas)
• Pour chaque pas de la chaîne de Markov
– Itérer sur chaque xk dans x
* Tirer xk de la loi conditionnelle P (xk |x−k )
Dans certains cas on peut regrouper les variables dans x en blocs ou groupes de variables tels que tirer d’un
groupe étant donnés les autres est facile. Dans ce cas il est avantageux d’interpréter l’algorithme ci-haut
avec xi le i-eme groupe plutôt que la i-eme variable. On appelle cela l’échantillonage de Gibbs par blocs.
9.6 Le Gradient dans un Champs de Markov Log-Linéaire
Voir Learning Deep Architectures for AI pour les dérivations en détail.
Les champs de Markov log-linéaires sont des modèles probabilistes non-dirigés où la fonction d’énergie est
linéaire en terme des paramètres θ du modèle:
P (x) ∝ e−
P
i θi fi (x)
où les fi (.) sont appelées les statistiques suffisantes du modèles car les espérances E[fi (x)] sont suffisantes
pour caractériser la distribution et estimer les paramètres. Notons que eθi fi (x) = ψi (x) est associé à chaque
clique du modèle (en général seulement un sous-vecteur de x influence fi (x)).
Revenons au statistiques suffisantes. On peut montrer que le gradient de la log-vraisemblance se développe
ainsi:
X
−∂ log P (x)
= fi (x) −
P (x)fi (x)
∂θi
x
et le gradient moyen sur les exemples d’apprentissage xt est donc
X
1 X −∂logP (xt )
1X
=
fi (xt ) −
P (x)fi (x)
T t
∂θi
T t
x
42
On voit donc que le gradient est annullé quand la moyenne des statistiques suffisantes sur la distribution
d’apprentissage égale leur espérance sur le modèle P.
Malheureusement, même calculer le gradient est difficile. On ne veut pas sommer sur tous les x possibles,
mais heureusement, on peut obtenir une approximation Monte-Carlo en faisant un ou plusieurs tirages de
P (x), ce qui donne un gradient stochastique. En général, cependant, même faire un tirage sans biais de
P (x) est exponentiellement coûteux, et on utilise donc une méthode MCMC.
On appelle ‘partie positive’ la partie du gradient dûe au numérateur de la probabilité (−fi (x)), et ‘partie
négative’ la partie correspondant au gradient de la fonction de partition (le dénominateur).
9.7 Marginalisation sur les variables cachées
Quand certaines variables sont cachées, le gradient devient un peu plus compliqué car il faut marginaliser
sur les variables cachées. Soit x = (v, h), avec v la partie visible et h la partie cachée, avec les statistiques
des fonctions des deux, fi (v, h). Le gradient moyen de la moins log-vraisemblance des données observées
devient
X
1 X −∂ log P (vt )
1 XX
P (h|vt )fi (vt , h) −
P (v, h)fi (v, h).
=
T t
∂θi
T t
h
h,v
Il faudra donc dans ce cas généralement se résoudre à du MCMC non seulement pour la partie négative mais
aussi pour la partie négative, pour échantillonner P (h|vt ).
9.7. Marginalisation sur les variables cachées
43
44
CHAPTER
TEN
LA MACHINE DE BOLTZMANN
La machine de Boltzmann est un modèle probabiliste non-dirigé, une forme particulière de champs de
Markov log-linéaire dans laquelle certaines variables sont observées (parfois) et d’autres ne le sont jamais
(les variables cachées), et où la fonction d’énergie est un polynôme du second degré par rapport aux
variables:
E(x) = −d0 x − x0 Ax
La machine de Boltzmann classique a des variables binaires et l’inférence est faite par une MCMC de Gibbs,
ce qui nécessite de faire des tirages de P (xi |x−i ), et l’on peut montrer facilement que
P (xi = 1|x−i ) = sigmoid(di + ωi x−i )
où ωi est la i-ème rangée de A sauf le i-ème élément, et dans ce modèle la diagonale de A est 0. On voit le
lien avec les réseaux de neurones.
10.1 La Machine de Boltzmann Restreinte
En anglais Restricted Boltzmann Machine ou RBM, c’est une machine de Boltzmann sans connections
latérales entre les vi ou entre les hi . La fonction d’énergie devient donc
E(v, h) = −b0 h − c0 v − v 0 W h.
où la matrice A est donc pleine de zéro sauf dans sa sous-matrice W. L’avantage de cette restriction dans la
connectivité est que l’inférence P (h|v) (et aussi P (v|h)) devient très facile et analytique et se factorise:
Y
P (h|v) =
P (hi |v)
i
et
P (v|h) =
Y
P (vi |h)
i
45
Dans le cas où les variables (= unités) sont binaires, on obtient encore la formule de neurone sigmoidal:
X
P (hj = 1|v) = sigmoid(bj +
Wij vi )
i
P (vi = 1|h) = sigmoid(ci +
X
Wij hj )
j
Un autre avantage de la RBM c’est qu’on peut calculer analytiquement P (v) a une constante près (cette
constante est la fonction de partition Z). Cela permet aussi de définir une généralisation de la notion de
fonction d’énergie au cas où on veut marginaliser sur les variables cachées: l’énergie libre (free energy,
aussi inspirée de considérations physiques):
P −E(v,h)
e
e−F E(v) X
P (v) =
=
P (v, h) = h
Z
Z
h
X
F E(v) = − log
e−E(v,h)
h
et dans le cas des RBMs, on a
F E(v) = −c0 v −
X
log
i
X
0
ehi (bi +v W.i )
hi
où la somme sur hi est une somme sur les valeurs que les variables cachées peuvent prendre, ce qui, dans le
cas d’unités binaires donne
X
0
F E(v) = −c0 v −
log(1 + ebi +v W.i )
i
0
F E(v) = −c v −
X
softplus(bi + v 0 W.i )
i
10.2 Gibbs dans les RBMs
Bien que tirer de P (h|v) est facile et immédiat dans une RBM, tirer de P (v) ou de P (v, h) ne peut pas se
faire de manière exacte et se fait donc généralement par une MCMC, la plus commune étant la MCMC de
Gibbs par bloc, où l’on prend avantage du fait que les tirages P (h|v) et P (v|h) sont faciles:
v (1) ∼ exemple d0 apprentissage
h(1) ∼ P (h|v (1) )
v (2) ∼ P (v|h(1) )
h(2) ∼ P (h|v (2) )
v (3) ∼ P (v|h(2) )
...
(k)
Pour visualiser les données générées à l’étape k, il vaut mieux utiliser les espérances (i.e. E[vi |h(k−1) ] =
(k)
P (vi = 1|h(k−1) )) qui sont moins bruitées que les échantillons v (k) eux-mêmes.
46
Chapter 10. La Machine de Boltzmann
CHAPTER
ELEVEN
ENTRAÎNEMENT DES RBMS
Le gradient exact sur les paramètres d’une RBM (pour un exemple v) est
∂ log P (v)
= v 0 E[h|v] − E[v 0 h]
∂W
∂ log P (v)
= E[h|v] − E[h]
∂b
∂ log P (v)
= v − E[v]
∂c
où les espérances sont prises sur la loi de la RBM. Les espérances conditionnelles sont calculables analytiquement (puisque E[hi |v] = P (hi = 1|v) = sortie du neurone caché, pour des hi binaires) mais les
espérances inconditionnelles doivent se faire par MCMC.
11.1 Divergence Contrastive
La première et plus simple approximation de E[v 0 h], i.e., pour obtenir des ‘exemples négatifs’ (pour la
‘partie négative’ du gradient), consiste à faire une courte chaîne de Gibbs (de k étapes) commencée sur
un exemple d’apprentissage. On appelle cet algorithme CD-k (Contrastive Divergence with k steps). Voir
l’algorithme 1 dans Learning Deep Architectures for AI:
0
0
W ← W + (v (1) ĥ(1) − v (2) ĥ(2) )
b ← b + (ĥ(1) − ĥ(2) )
c ← c + (v (1) − v (2) )
où est le pas de gradient, et l’on réfère à la notation de la chaîne de Gibbs des RBMs ci-haut, avec ĥ(1)
(1)
(2)
(2)
dénote le vecteur des probabilités P (hi = 1|v1 ) et de la même manière ĥi = P (hi = 1|v (2) ).
Ce qui est étonnant c’est que même avec k=1, on obtient des RBMs qui fonctionnent bien dans le sens
qu’elles extraient des bonnes caractéristiques des entrées (ce qu’on peut vérifier visuellement en regardant
les filtres, les reconstructions stochastiques après 1 étape de Gibbs, ou bien quantitativement en initialisant
chaque couche d’un réseau profond avec W et b par pré-entraînement de la RBM associée à chaque couche).
On peut montrer que CD-1 est très proche de l’entraînement d’un auto-encodeur par minimisation de l’erreur
de reconstruction, et on voit que l’erreur de reconstruction diminue de manière assez monotone pendant
l’entraînement par CD-1.
47
On peut aussi montrer que CD-k tends vers le vrai gradient (en espérance) quand k devient grand, mais à ce
moment on multiplie le temps de calcul par k.
11.2 Divergence Contrastive Persistente
Pour obtenir un estimateur moins biaisé du vrai gradient sans augmenter beaucoup le temps de calcul, on
peut utiliser l’algorithme de Divergence Contrastive Persistente (en anglais Persistent Contrastive Divergence, ou PCD). Plutôt que de redémarrer une chaîne de Gibbs après avoir vu chaque exemple v, il s’agit
de garder une chaîne de Gibbs toujours en activité pour obtenir nos échantillons d’exemples négatifs. Cette
chaîne est un peu particulière car ses probabilités de transition changent (lentement), au fur et à mesure
qu’on met à jour les paramètres de la RBM. Soit (v − , h− ) l’état de notre chaîne négative. L’algorithme
d’apprentissage est le suivant:
ĥi = P (hi = 1|v)
∀i, v̂i− = P (vi = 1|h− )
v − ∼ v̂ −
−
∀i, hbi = P (hi = 1|v − )
h− ∼ ĥ−
0
W ← W + (v ĥ0 − v − ĥ− )
b ← b + (ĥ − ĥ− )
c ← c + (v − v̂ − )
On trouve expérimentalement que PCD est meilleur en terme de génération d’exemples (et en terme de
vraisemblance log P (v)) que CD-k, et est moins sensible à l’initialisation de la chaîne de Gibbs.
48
Chapter 11. Entraînement des RBMs
CHAPTER
TWELVE
RBMS EMPILÉS ET DBNS
On peut utiliser les RBMs comme les auto-encodeurs, pour pré-entraîner de manière non-supervisée un
réseau de neurones profonds, pour ensuite finaliser son entraînement de manière supervisée habituelle. On
va donc empiler les RBMs, la couche cachée de l’un (étant donnée son entrée), i.e., les P (h|v) ou bien des
h ∼ P (h|v), devenant l’entrée de la couche suivante.
Le pseudo-code de l’entraînement vorace couche par couche d’une pile de RBMs est présenté dans la section
6.1 (algorithme 2) de Learning Deep Architectures for AI. Pour entraîner la k-ième RBM, on propage soit
des échantillons (h ∼ P (h|v)) ou des posterieurs (P (h|v)) à travers les k-1 premières RBMs, et on les
utilise comme données d’entraînement pour la k-ième RBM. On les entraîne donc une à la fois: une fois
qu’on arrête l’entraînement de la k-ième, on peut procéder à la k+1 ième.
Une RBM a la même paramétrisation qu’une couche classique de réseau de neurones (avec des unités
sigmoides), à la différence près qu’on utilise seulement les poids W et les biais b des unités cachées (car on
a seulement besoin de P (h|v) et non pas de P (v|h)).
12.1 Deep Belief Networks
On peut aussi considérer un empilement de RBMs de manière générative, et l’on appelle ce modèle le Deep
Belief Network:
!
`−2
Y
P (x, h1 , . . . , h` ) =
P (hk |hk+1 ) P (h`−1 , h` )
k=0
h0
où l’on dénote x =
et la variable (vecteur) aléatoire associée à la couche k est hk . Les deux dernières
couches ont une distribution jointe qui est donnée par une RBM (la dernière de la pile). Les RBMs du
dessous servent seulement à définir les probabilités conditionnelles P (hk |hk+1 ) du DBN, où hk joue le rôle
d’unités visibles et hk+1 joue celui des unités cachées dans la RBM k+1.
Échantilloner d’un DBN se fait donc ainsi:
• échantillonner un h`−1 de la RBM du dessus (numéro `), par exemple en faisant du Gibbs
• pour k de ` − 1 à 1
– échantillonner les unités visibles (hk ) étant données les unités cachées (hk+1 ) dans la RBM
k
• retourner le dernier échantillon produit hk , qui est le résultat de la génération par le DBN
49
12.2 Dépliement d’une RBM et équivalence RBM - DBN
On peut montrer (voir section 8.1 de Learning Deep Architectures for AI.) qu’une RBM correspond à un
DBN avec une architecture particulière, dont les poids sont partagés entre toutes les couches: le niveau 1 du
DBN utilise les poids W de la RBM, le niveau 2 utilise les poids W’, le niveau 3 utilise les poids W, etc. en
alternant entre W et W’. La dernière paire de couches du DBN est une RBM avec les poids W ou W’ selon
qu’on déplie un nombre impair ou pair de couches. Remarquons que dans cette équivalence, le DBN a des
tailles de couches qui alternent (nombre de visibles de la RBM, nombre de cachées de la RBM, nombre de
visibles de la RBM, etc.).
En fait on peut continuer le dépliement d’une RBM jusqu’à l’infini et obtenir un réseau dirigé infini à poids
partagés, équivalent. Voir la figure 13 de la même section 8.1. On peut voir que ce réseau infini correspond
exactement à une chaîne de Gibbs (infinie) qui culmine (finit) sur la couche visible de la RBM originale,
i.e., qui génère les mêmes exemples. Les couches paires correspondent à échantillonner P(v|h) (de la RBM
originale) et les couches impaires à échantillonner P(h|v).
Finalement, on peut montrer que si on prend une RBM, qu’on la déplie une fois (en miroir), le fait de continuer l’entraînement de la nouvelle RBM du dessus (initialisée avec W’) va maximiser une borne inférieure sur
la vraisemblance du DBN correspondant. Dans le passage d’une RBM à un DBN, on remplace la marginale
P(h) de la RBM (qui est obtenue implicitement à travers les paramètres de la RBM, et par exemple une
chaîne de Gibbs dans la RBM) par la distribution générée par la partie de DBN au-dessus de cette RBM (le
DBN formé de toutes les couches au-dessus de h), puisque ce h correspond aux unités visibles de ce DBN.
La démo est simple et instructive, et utilise la lettre Q pour les probabilités selon la RBM (du bas) et la lettre
P pour les probabilités selon la DBN obtenue en modélisant les h différemment (i.e. en remplaçant Q(h) par
P(h)). On remarque aussi que P(x|h)=Q(x|h), mais ce n’est pas vrai pour P(h|x) et Q(h|x).
!
X
X
P (x, h)
log P (x) =
Q(h|x) log P (x) =
Q(h|x) log
P (h|x)
h
h
X
P (x, h) Q(h|x)
log P (x) =
Q(h|x) log
P (h|x) Q(h|x)
h
X
X
Q(h|x)
log P (x) = HQ(h|x) +
Q(h|x) log P (x, h) +
Q(h|x) log
P (h|x)
h
h
X
log P (x) = KL(Q(h|x)||P (h|x)) + HQ(h|x) +
Q(h|x) (log P (h) + log P (x|h))
h
log P (x) ≥
X
h
On voit donc effectivement que l’on peut augmenter la borne inférieure (dernière ligne) en faisant de
l’entraînement maximum de vraisemblance de P(h) utilisant comme données d’entraînement des h tirés
de Q(h|x), où x est tiré de la distribution d’entraînement de la RBM du dessous. Étant donné qu’on a découplé les poids du dessous de ceux du dessus, on ne touche pas à la RBM du dessous (P(x|h) et Q(h|x)), on
modifie seulement P(h).
50
Chapter 12. RBMs empilés et DBNs
12.3 Inférence approximative dans les DBNs
Contrairement à la RBM, l’inférence dans les DBNs (choisir les unités cachées étant données les entrées
visibles) est très difficile. Étant donné qu’on initialise les DBNs comme une pile de RBMs, on utilise en
pratique l’approximation suivante: on échantillonne les hk étant donné les hk−1 en utilisant les poids du
niveau k. Il s’agirait de l’inférence exacte si c’était effectivement une RBM isolée, mais ça ne l’est plus avec
le DBN.
On a vu que c’est une approximation à la section précédente parce que la marginale P(h) (du DBN) diffère
de la marginale Q(h) (de la RBM du dessous), après qu’on modifie les poids du dessus qui ne sont plus la
transposée des poids du dessous, et donc P(h|x) diffère de Q(h|x).
12.4 Deep Boltzmann Machine
Finalement, on peut aussi utiliser un empilement de RBMs pour initializer une machine de Boltzmann profonde (Salakhutdinov et Hinton, AISTATS 2009: http://www.mit.edu/~rsalakhu/papers/dbm.pdf). Il s’agit
d’une machine de Boltzmann organisée en couches, où chaque couche est seulement connectée à celle du
dessous et celle du dessus.
On remarque que les poids sont en quelque sorte deux fois trop gros quand on fait cette initialisation, car
maintenant chaque unité reçoit son entrée de la couche au-dessus d’elle et aussi de la couche d’en dessous,
alors que dans la RBM originale c’était soit de l’un, ou de l’autre. Salakhutdinov propose donc de diviser les
poids par deux quand on fait le passage de l’empilement de RBMs vers la machine de Boltzmann profonde.
Il est intéressant de noter aussi que selon Salakhutdinov, il est crucial de faire l’initialisation de la machine
de Boltzmann profonde à partir de l’empilement de RBMs, plutôt qu’à partir de poids aléatoires. Cela
suggère que la difficulté d’entraînement des réseaux MLP profonds déterministes ne leur est pas unique, et
qu’une difficulté semblable se retrouve dans les machines de Boltzmann profondes. Dans les deux cas, le fait
d’initialiser chaque couche selon un entraînement local à la couche semble aider beaucoup. Salakutdinov
obtient des résultats meilleurs avec sa machine de Boltzmann profonde qu’avec un DBN équivalent, mais
l’entraînement est plus long.
Voir cet article:
An Efficient Learning Procedure for Deep Boltzmann Machines. Ruslan Salakhutdinov and Geoffrey Hinton. MIT Technical Report MIT-CSAIL-TR-2010-037, 2010 http://www.mit.edu/~rsalakhu/papers/MITCSAIL-TR-2010-037.pdf
Pour accélérer l’inférence dans les DBMs:
Efficient Learning of Deep Boltzmann Machines. Ruslan Salakhutdinov and Hugo Larochelle. AI and
Statistics, 2010 http://www.mit.edu/~rsalakhu/papers/dbmrec.pdf
Version en français
12.3. Inférence approximative dans les DBNs
51
52
Chapter 12. RBMs empilés et DBNs
CHAPTER
THIRTEEN
CONTENTS
13.1 IFT6266: Course Outline
The following table contains a summary of each class of the course (click on the date for more details for
each entry):
53
Date
April 2nd
March
29th
March
26th
Subject
Exam
Review session
To read
Convolutional networks
March
22nd
March
19th
March
15th
March
12th
March 1st
February
27th
February
20th+23rd
February
13rd+16th
February
6th+9th
February
2nd
Gradient propagation
DAE vs AE
Challenges for deep networks
Neocognitron article.
LeNet article.
Convolutional networks tutorial.
final part of Yoshua Bengio’s presentation.
Denoising autoencoders vs. ordinary autoencoders.
The challenges of training deep neural networks.
January
30th
January
26th
January
23rd
January
19th
January
16th
January
12th
January
9th
January
5th
Probabilistic models
54
Pre-training
Contracting AE,
DBMs
Yoshua Bengio’s presentation.
Dumitru Erhan presentation.
Articles on Contracting Auto-Encoders and on Manifold
Tangent Classifier
Article on Contracting Auto-Encoders
The Boltzmann Machine.
DBNs
Stacked RBMs and DBNs.
RBMs
Restricted Boltzmann Machines.
Computing gradients
Probabilistic models Probabilistic models for deep
architectures.
Introduction to Probabilistic models for deep
architectures.
Jobman.
Introduction to Probabilistic models for deep
architectures.
Section 4.6 de Learning Deep Architectures for AI.
Denoising Auto-Encoders
Documentation on python, numpy, et Theano. Logistic
regression tutorial. Notes on training MLPs.
Efficient Backprop. Introduction to the Deep Learning
Tutorials. The Getting Started tutorial.
Notes on computing gradients.
Introduction to deep
networks
Introduction to deep
networks
Introduction to this class
Introduction to Machine
Learning
Introduction to deep networks, Sec. 1 of Learning Deep
Architectures for AI. Notes on gradient based learning.
Introduction to deep networks, Sec. 1 of Learning Deep
Architectures for AI.
course outline .
slides . Introduction to Machine Learning, Sec. 1 and 2 of
Scaling Learning Algorithms towards AI.
Contracting AE and MTC
Launching jobs
Auto-encoders, DAE
python, numpy, Theano
Logistical regression
Neural networks
Chapter 13. Contents
13.1.1 April 2nd
• Open book theoretical exam
13.1.2 March 29th
• Review session before the exam
13.1.3 March 26th
• Convolutional neural networks
– Neocognitron
– LeNet
– Convolutional neural networks tutorial
13.1.4 March 22nd
• Gradient propagation for deep neural networks: Yoshua Bengio’s presentation, May 2010.
• Denoising autoencoders vs. ordinary autoencoders.
13.1.5 March 19th
• The challenges of training deep neural networks.
13.1.6 March 15th
• Understanding the effects of non-supervised pre-training: Yoshua Bengio’s presentation, May 2010.
• Understanding the effects of non-supervised pre-training: Dumitru Erhan’s presentation, March 2010.
13.1.7 March 12th
• Articles on Contracting Auto-Encoders and on Manifold Tangent Classifier
13.1.8 March 1st
• Article on Contracting Auto-Encoders.
13.1.9 February 27th
• The Boltzmann Machine.
13.1. IFT6266: Course Outline
55
13.1.10 February 20th+23rd
• Stacked RBMs and DBNs.
13.1.11 February 13rd+16th
• Restricted Boltzmann Machines.
13.1.12 February 6th+9th
• More of Probabilistic models for deep architectures.
13.1.13 February 2nd
• More on introduction to Probabilistic models for deep architectures.
13.1.14 January 30th
• Introduction to Probabilistic models for deep architectures.
• On training neural networks:
– Controlling capacity Training Multi-Layer Neural Networks
• Auto-Encoders
– Survery on auto-encoders: section 4.6 of Learning Deep Architectures for AI
– Denoising auto-encoders tutorial
13.1.16 January 23rd
• Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)
– The Back-Propagation Algorithm
– Logistic Regression
– Training Multi-Layer Neural Networks
• Introduction
to
the
Deep
<http://deeplearning.net/tutorial/intro.html>‘_
56
Learning
Tutorials
(using
Theano)
• Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)
– Multi-Layer Neural Networks
– Most Common Training Criteria and Output Non-Linearities
• Introduction to Theano
• Introduction
to
the
Deep
<http://deeplearning.net/tutorial/intro.html>‘_
Learning
Tutorials
(using
Theano)
• Introduction to Gradient-Based Learning
– Flow Graphs, Chain Rule and Backpropagation: Efficient Computation of the Gradient
• Introduction to deep learning
– Breakthrough in Learning Deep Architectures
• Introduction to Gradient-Based Learning
– The Gradient
– Gradient Descent
– Stochastic Gradient Descent
13.1.20 January 9th
• Introduction to Deep Learning Algorithms
13.1.21 January 5th
• Introduction and motivation of the course as well as evaluation methodology (course outlie)
• Very Brief Introduction to Machine Learning for AI
13.2 Very Brief Introduction to Machine Learning for AI
The topics summarized here are covered in these slides.
13.2. Very Brief Introduction to Machine Learning for AI
57
13.2.1 Intelligence
The notion of intelligence can be defined in many ways. Here we define it as the ability to take the right
decisions, according to some criterion (e.g. survival and reproduction, for most animals). To take better
decisions requires knowledge, in a form that is operational, i.e., can be used to interpret sensory data and
use that information to take decisions.
13.2.2 Artificial Intelligence
Computers already possess some intelligence thanks to all the programs that humans have crafted and which
allow them to “do things” that we consider useful (and that is basically what we mean for a computer to take
the right decisions). But there are many tasks which animals and humans are able to do rather easily but
remain out of reach of computers, at the beginning of the 21st century. Many of these tasks fall under the
label of Artificial Intelligence, and include many perception and control tasks. Why is it that we have failed
to write programs for these tasks? I believe that it is mostly because we do not know explicitly (formally)
how to do these tasks, even though our brain (coupled with a body) can do them. Doing those tasks involve
knowledge that is currently implicit, but we have information about those tasks through data and examples
(e.g. observations of what a human would do given a particular request or input). How do we get machines to
acquire that kind of intelligence? Using data and examples to build operational knowledge is what learning
is about.
13.2.3 Machine Learning
Machine learning has a long history and numerous textbooks have been written that do a good job of covering
its main principles. Among the recent ones I suggest:
• Christopher M. Bishop, “Pattern Recognition and Machine Learning”, 2007
• Simon Haykin, “Neural Networks: a Comprehensive Foundation”, 2009 (3rd edition)
• Richard O. Duda, Peter E. Hart and David G. Stork, “Pattern Classification”, 2001 (2nd edition)
Here we focus on a few concepts that are most relevant to this course.
13.2.4 Formalization of Learning
First, let us formalize the most common mathematical framework for learning. We are given training examples
D = {z1 , z2 , . . . , zn }
with the zi being examples sampled from an unknown process P (Z). We are also given a loss functional L
which takes as argument a decision function f and an example z, and returns a real-valued scalar. We want
to minimize the expected value of L(f, Z) under the unknown generating process P (Z).
58
13.2.5 Supervised Learning
In supervised learning, each examples is an (input,target) pair: Z = (X, Y ) and f takes an X as argument.
The most common examples are
• regression: Y is a real-valued scalar or vector, the output of f is in the same set of values as Y , and
we often take as loss functional the squared error
L(f, (X, Y )) = ||f (X) − Y ||2
• classification: Y is a finite integer (e.g. a symbol) corresponding to a class index, and we often take
as loss function the negative conditional log-likelihood, with the interpretation that fi (X) estimates
P (Y = i|X):
L(f, (X, Y )) = − log fY (X)
where we have the constraints
fY (X) ≥ 0 ,
X
fi (X) = 1
i
13.2.6 Unsupervised Learning
In unsupervised learning we are learning a function f which helps to characterize the unknown distribution
P (Z). Sometimes f is directly an estimator of P (Z) itself (this is called density estimation). In many other
cases f is an attempt to characterize where the density concentrates.
Clustering algorithms divide up the input space in regions (often centered around a prototype example or
centroid). Some clustering algorithms create a hard partition (e.g. the k-means algorithm) while others
construct a soft partition (e.g. a Gaussian mixture model) which assign to each Z a probability of belonging
to each cluster.
Another kind of unsupervised learning algorithms are those that construct a new representation for Z. Many
deep learning algorithms fall in this category, and so does Principal Components Analysis.
13.2.7 Local Generalization
The vast majority of learning algorithms exploit a single principle for achieving generalization: local generalization. It assumes that if input example xi is close to input example xj , then the corresponding outputs
f (xi ) and f (xj ) should also be close. This is basically the principle used to perform local interpolation.
This principle is very powerful, but it has limitations: what if we have to extrapolate? or equivalently, what
if the target unknown function has many more variations than the number of training examples? in that case
there is no way that local generalization will work, because we need at least as many examples as there are
ups and downs of the target function, in order to cover those variations and be able to generalize by this
principle.
13.2. Very Brief Introduction to Machine Learning for AI
59
This issue is deeply connected to the so-called curse of dimensionality for the following reason. When the
input space is high-dimensional, it is easy for it to have a number of variations of interest that is exponential
in the number of input dimensions. For example, imagine that we want to distinguish between 10 different
values of each input variable (each element of the input vector), and that we care about about all the 10n
configurations of these n variables. Using only local generalization, we need to see at least one example of
each of these 10n configurations in order to be able to generalize to all of them.
13.2.8 Distributed versus Local Representation and Non-Local Generalization
A simple-minded binary local representation of integer N is a sequence of B bits such that N < B, and
all bits are 0 except the N -th one. A simple-minded binary distributed representation of integer N is a
sequence of B = log2 N + 1 bits with the usual binary encoding for N . In this example we see that
distributed representations can be exponentially more efficient than local ones. In general, for learning
algorithms, distributed representations have the potential to capture exponentially more variations than local
ones for the same number of free parameters. They hence offer the potential for better generalization because
learning theory shows that the number of examples needed (to achieve a desired degree of generalization
performance) to tune O(B) effective degrees of freedom is O(B).
Another illustration of the difference between distributed and local representation (and corresponding local
and non-local generalization) is with (traditional) clustering versus Principal Component Analysis (PCA) or
Restricted Boltzmann Machines (RBMs). The former is local while the latter is distributed. With k-means
clustering we maintain a vector of parameters for each prototype, i.e., one for each of the regions distinguishable by the learner. With PCA we represent the distribution by keeping track of its major directions
of variations. Now imagine a simplified interpretation of PCA in which we care mostly, for each direction
of variation, whether the projection of the data in that direction is above or below a threshold. With d directions, we can thus distinguish between 2d regions. RBMs are similar in that they define d hyper-planes
and associate a bit to an indicator of being on one side or the other of each hyper-plane. An RBM therefore
associates one input region to each configuration of the representation bits (these bits are called the hidden
units, in neural network parlance). The number of parameters of the RBM is roughly equal to the number
these bits times the input dimension.
Again, we see that the number of regions representable by an RBM or a PCA (distributed representation) can
grow exponentially in the number of parameters, whereas the number of regions representable by traditional
clustering (e.g. k-means or Gaussian mixture, local representation) grows only linearly with the number of
parameters. Another way to look at this is to realize that an RBM can generalize to a new region corresponding to a configuration of its hidden unit bits for which no example was seen, something not possible
for clustering algorithms (except in the trivial sense of locally generalizing to that new regions what has
been learned for the nearby regions for which examples have been seen).
13.3 Introduction to Deep Learning Algorithms
See the following article for a recent survey of deep learning:
Yoshua Bengio, Learning Deep Architectures for AI, Foundations and Trends in Machine Learning, 2(1),
2009
60
13.3.1 Depth
The computations involved in producing an output from an input can be represented by a flow graph: a flow
graph is a graph representing a computation, in which each node represents an elementary computation and
a value (the result of the computation, applied to the values at the children of that node). Consider the set
of computations allowed in each node and possible graph structures and this defines a family of functions.
Input nodes have no children. Output nodes have no parents.
The flow graph for the expression sin(a2 + b/a) could be represented by a graph with two input nodes a
and b, one node for the division b/a taking a and b as input (i.e. as children), one node for the square (taking
only a as input), one node for the addition (whose value would be a2 + b/a) and taking as input the nodes a2
and b/a, and finally one output node computing the sinus, and with a single input coming from the addition
node.
A particular property of such flow graphs is depth: the length of the longest path from an input to an output.
Traditional feedforward neural networks can be considered to have depth equal to the number of layers (i.e.
the number of hidden layers plus 1, for the output layer). Support Vector Machines (SVMs) have depth 2
(a first level for the kernel outputs or for the feature space, and a second level for the linear combination
producing the output).
13.3.2 Motivations for Deep Architectures
The main motivations for studying learning algorithms for deep architectures are the following:
• Insufficient depth can hurt
• The brain has a deep architecture
• Cognitive processes seem deep
• Statistical sharing
13.3.3 Insufficient depth can hurt
Depth 2 is enough in many cases (e.g. logical gates, formal [threshold] neurons, sigmoid-neurons, Radial
Basis Function [RBF] units like in SVMs) to represent any function with a given target accuracy. But this
may come with a price: that the required number of nodes in the graph (i.e. computations, and also number
of parameters, when we try to learn the function) may grow very large. Theoretical results showed that
there exist function families for which in fact the required number of nodes may grow exponentially with
the input size. This has been shown for logical gates, formal neurons, and RBF units. In the latter case
Hastad has shown families of functions which can be efficiently (compactly) represented with O(n) nodes
(for n inputs) when depth is d, but for which an exponential number (O(2n )) of nodes is needed if depth is
restricted to d − 1.
One can see a deep architecture as a kind of factorization. Most randomly chosen functions can’t be represented efficiently, whether with a deep or a shallow architecture. But many that can be represented efficiently
with a deep architecture cannot be represented efficiently with a shallow one (see the polynomials example
in the Bengio survey paper). The existence of a compact and deep representation indicates that some kind of
13.3. Introduction to Deep Learning Algorithms
61
structure exists in the underlying function to be represented. If there was no structure whatsoever, it would
not be possible to generalize well.
13.3.4 The brain has a deep architecture
For example, the visual cortex is well-studied and shows a sequence of areas each of which contains a
representation of the input, and signals flow from one to the next (there are also skip connections and at
some level parallel paths, so the picture is more complex). Each level of this feature hierarchy represents
the input at a different level of abstraction, with more abstract features further up in the hierarchy, defined
in terms of the lower-level ones.
Note that representations in the brain are in between dense distributed and purely local: they are sparse:
about 1% of neurons are active simultaneously in the brain. Given the huge number of neurons, this is still
a very efficient (exponentially efficient) representation.
13.3.5 Cognitive processes seem deep
• Humans organize their ideas and concepts hierarchically.
• Humans first learn simpler concepts and then compose them to represent more abstract ones.
• Engineers break-up solutions into multiple levels of abstraction and processing
It would be nice to learn / discover these concepts (knowledge engineering failed because of poor introspection?). Introspection of linguistically expressible concepts also suggests a sparse representation: only a
small fraction of all possible words/concepts are applicable to a particular input (say a visual scene).
13.3.6 Statistical Sharing
Intermediate representations can be exploited to share statistical strength across different contexts. First, if
deeper architectures can be more efficient in terms of number of computational units (to represent the same
function), that in principle means that the number of parameters than need to be estimated is smaller, which
gives rise to greater statistical efficiency.
Another way to see this is to consider the sharing of statistical strength that occurs when different components of an architecture are re-used for different purposes (e.g., in the computation for different outputs, or
different tasks, or in the computation for different intermediate features). Since the parameters of a component are used for different purposes, they share statistical strength among the different examples (or parts of
examples) that rely on these parameters: using more examples, from more contexts, gives more information
on these parameters, allowing to reduce the uncertainty on their values.
This is similar and related to the sharing of statistical strength that occurs in distributed representations. For
example, if the parameters of one hidden unit of an RBM are “used” for many examples (because that unit
turns on for many examples), then there is more information available to estimate those parameters. When
a new configuration of the input is presented, it may not correspond to any of those seen in the training set,
but its “components” (possibly represented at a higher level of abstraction in intermediate representations)
may have been seen previously.
62
Sharing of statistical strength is a core idea behind many advances in machine learning. Components and
parameters are shared across tasks in the case of multi-task learning, and deep architectures are particularly
well suited for multi-task learning~(Collobert & Weston, ICML‘2008). Similarly semi-supervised learning
exploits statistical sharing between the tasks of learning the input distribution P(X) and learning the conditional distribution P(Y|X). Because deep learning algorithms often rely heavily on unsupervised learning,
they are well suited to exploit this particular form of statistical sharing.
A very related form of sharing occurs in self-taught learning~(Raina et al, 2007), whereby we consider
unlabeled training data from P(X|Y) for a set of classes Y’s but really care about generalizing to tasks
P(Y|X) for a different set of Y’s. Recent work showed that deep learners benefit more from the self-taught
learning and multi-task learning frameworks than shallow learners~(Bengio et al, NIPS 2010 deep learning
workshop).
This is also a form of out-of-domain generalization, for which deep learners are also well suited, as shown
in (Bengio et al, NIPS 2010 deep learning workshop) for pattern recognition and in (Glorot et al, 2011) for
natural language processing (sentiment analysis).
13.3.7 Breakthrough in Learning Deep Architectures
Before 2006, attempts at training deep architectures failed: training a deep supervised feedforward neural
network tends to yield worse results (both in training and in test error) then shallow ones (with 1 or 2 hidden
layers).
Three papers changed that in 2006, spearheaded by Hinton’s revolutionary work on Deep Belief Networks
(DBNs):
• Hinton, G. E., Osindero, S. and Teh, Y., A fast learning algorithm for deep belief nets Neural Computation 18:1527-1554, 2006
• Yoshua Bengio, Pascal Lamblin, Dan Popovici and Hugo Larochelle, Greedy Layer-Wise Training of
Deep Networks, in J. Platt et al. (Eds), Advances in Neural Information Processing Systems 19 (NIPS
2006), pp. 153-160, MIT Press, 2007
• Marc’Aurelio Ranzato, Christopher Poultney, Sumit Chopra and Yann LeCun, Efficient Learning of
Sparse Representations with an Energy-Based Model, in J. Platt et al. (Eds), Advances in Neural
Information Processing Systems (NIPS 2006), MIT Press, 2007
The following key principles are found in all three papers:
• Unsupervised learning of representations is used to (pre-)train each layer.
• Unsupervised training of one layer at a time, on top of the previously trained ones. The representation
learned at each level is the input for the next layer.
• Use supervised training to fine-tune all the layers (in addition to one or more additional layers that are
dedicated to producing predictions).
The DBNs use RBMs for unsupervised learning of representation at each layer. The Bengio et al paper
explores and compares RBMs and auto-encoders (neural network that predicts its input, through a bottleneck
internal layer of representation). The Ranzato et al paper uses sparse auto-encoder (which is similar to sparse
coding) in the context of a convolutional architecture. Auto-encoders and convolutional architectures will
be covered later in the course.
13.3. Introduction to Deep Learning Algorithms
63
Since 2006, a plethora of other papers on the subject of deep learning has been published, some of them exploiting other principles to guide training of intermediate representations. See Learning Deep Architectures
for AI for a survey.
13.4 Introduction to Gradient-Based Learning
Consider a cost function C which maps a parameter vector θ to a scalar C(θ) which we would like to minimize. In machine learning the cost function is typically the average or the expectation of a loss functional:
n
C(θ) =
1X
L(fθ , zi )
n
i=1
(this is called the training loss) or
Z
C(θ) =
L(fθ , z)P (z)dz
(this is called the generalization loss), where in supervised learning we have z = (x, y) and fθ (x) is a
prediction of y, indexed by the parameters theta.
13.4.1 The Gradient
The gradient of the function C of a single scalar θ is formally defined as follows:
C(θ + δθ) − C(θ)
∂C(θ)
= lim
δθ→0
∂θ
δθ
Hence it is the variation ∆C induced by a change ∆θ, when ∆θ is very small.
∂C(θ)
When θ is a vector, the gradient ∂C(θ)
∂θ is a vector with one element ∂θi per θi , where we consider the other
parameters fixed, we only make the change ∆θi and we measure the resulting ∆C. When ∆θi is small then
∂C(θ)
∆C
∆θi becomes ∂θi .
13.4.2 Gradient Descent
We want to find a θ that minimizes C(θ). If we are able to solve
∂C(θ)
=0
∂θ
then we can find the minima (and maxima and saddle points), but in general we are not able to find the
solutions of this equation, so we use numerical optimization methods. Most of these are based on the idea
64
of local descent: iteratively modify θ so as to decrease C(θ), until we cannot anymore, i.e., we have arrived
at a local minimum (maybe global if we are lucky).
The simplest of all these gradient-based optimization techniques is gradient descent. There are many variants
of gradient descent, so we define here ordinary gradient descent:
θk+1 = θk − k
∂C(θk )
∂θk
where θk represents our parameters at iteration k and k is a scalar that is called the learning rate, which
can either be chosen fixed, adaptive or according to a fixed decreasing schedule.
13.4.3 Stochastic Gradient Descent
We exploit the fact that C is an average, generally over i.i.d. (independently and identically distributed) examples, to make updates to θ much more often, in the extreme (and most common) case after each example:
θk+1 = θk − k
∂L(θk , z)
∂θk
where z is the next example from the training set, or the next example sampled from the training distribution,
in the online setting (where we have not a fixed-size training set but instead access to a stream of examples
from the data generating process). Stochastic Gradient Descent (SGD) is a more general principle in which
the update direction is a random variable whose expectations is the true gradient of interest. The convergence
conditions of SGD are similar to those for gradient descent, in spite of the added randomness.
SGD can be much faster than ordinary (also called batch) gradient descent, because it makes updates much
more often. This is especially true for large datasets, or in the online setting. In fact, in machine learning
tasks, one only uses ordinary gradient descent instead of SGD when the function to minimize cannot be
decomposed as above (as a mean).
13.4.4 Minibatch Stochastic Gradient Descent
This is a minor variation on SGD in which we obtain the update direction by taking the average over a small
batch (minibatch) of B examples (e.g. 10, 20 or 100). The main advantage is that instead of doing B Vector
x Matrix products one can often do a Matrix x Matrix product where the first matrix has B rows, and the
latter can be implemented more efficiently (sometimes 2 to 10 times faster, depending on the sizes of the
matrices).
Minibatch SGD has the advantage that it works with a slightly less noisy estimate of the gradient (more so as
B increases). However, as the minibatch size increases, the number of updates done per computation done
decreases (eventually it becomes very inefficient, like batch gradient descent). There is an optimal trade-off
(in terms of computational efficiency) that may vary depending on the data distribution and the particulars of
the class of function considered, as well as how computations are implemented (e.g. parallelism can make a
difference).
13.4. Introduction to Gradient-Based Learning
65
13.4.5 Momentum
Another variation that is similar in spirit to minibatch SGD is the use of so-called momentum: the idea is
to compute on-the-fly (online) a moving average of the past gradients, and use this moving average instead
of the current example’s gradient, in the update equation. The moving average is typically an exponentially
decaying moving average, i.e.,
∆θk+1 = α∆θk + (1 − α)
∂L(θk , z)
∂θk
where α is a hyper-parameter that controls how much weight is given in this average to older vs most recent
gradients.
13.4.6 Choosing the Learning Rate Schedule
If the step size is too large – larger than twice the largest eigenvalue of the second derivative matrix (Hessian) of C –, then gradient steps will go upward instead of downward. If the step size is too small, then
convergence is slower.
The most common choices of learning rate schedule (k ) are the following:
• constant schedule, k = 0 : this is the most common choice. It in theory gives an exponentially larger
weight to recent examples, and is particularly appropriate in a non-stationary environment, where the
distribution may change. It is very robust but error will stop improving after a while, where a smaller
learning rate could yield a more precise solution (approaching the minimum a bit more).
τ
• 1/k schedule: k = 0 τ +k
.
This schedule is guaranteed to reach asymptotic convergence (as k → ∞) because it satisfies the
following requirements:
∞
X
k = ∞
k=1
∞
X
2k < ∞
k=1
and this is true for any τ but 0 must be small enough to avoid divergence, where the error rises instead
of decreasing.
A disadvantage is that an additional hyper-parameter τ is introduced. Another is that in spite of its
guarantees, a poor choice of τ can yield very slow convergence.
66
13.4.7 Flow Graphs, Chain Rule and Backpropagation: Efficient Computation of
the Gradient
Consider a function (in our case it is L(θ, z)) of several arguments, and we wish to compute it as well as
its derivative (gradient) w.r.t. some of its arguments. We will decompose the computation of the function in
terms of elementary computations for which partial derivatives are easy to compute, forming a flow graph
(as already discussed there). A flow graph is an acyclic graph where each node represents the result of a
computation that is performed using the values associated with connected nodes of the graph. It has input
nodes (with no predecessors) and output nodes (with no successors).
Each node of the flow graph is associated with a symbolic expression that defines how its value is computed
in terms of the values of its children (the nodes from which it takes its input). We will focus on flow graphs
for the purpose of efficiently computing gradients, so we will keep track of gradients with respect to a special
output node (denoted L here to refer to a loss to be differentiated with respect to parameters, in our case).
We will associate with each node
• the node value
• the symbolic expression that specifies how to compute the node value in terms of the value of its
predecessors (children)
• the partial derivative of L with respect to the node value
• the symbolic expressions that specify to how compute the partial derivative of each node value with
respect to the values of its predecessors.
Let L be the output scalar node of the flow graph, and consider an arbitrary node u whose parents (the nodes
taking the value computed at u as input) are vi . In addition to the value u (abuse of notation) associated with
node u, we will also associate with each node u a partial derivative ∂L
∂u .
The chain rule for derivatives specifies how the partial derivative
∂L
for its parents vi :
sively from the partial derivatives ∂v
i
∂L
∂u
for a node u can be obtained recur-
∂L X ∂L ∂vi
=
∂u
∂vi ∂u
i
Note that ∂L
∂L = 1 which starts the recursion at the root node of the graph (node that in general it is a graph,
not a tree, because there may be multiple paths from a given node to the root – output – node). Note also
i
that each ∂v
∂u is an expression (and a corresponding value, when the inputs are given) that is associated with
an arc of the graph (and each arc is associated with one such partial derivative).
Note how the gradient computations involved in this recipe go exactly in the opposite direction compared
to those required to compute L. In fact we say that gradients are back-propagated, following the arcs
backwards. The instantiation of this procedure for computing gradients in the case of feedforward multilayer neural networks is called the back-propagation algorithm.
In the example already shown earlier, L = sin(a2 + b/a) and there are two paths from a to L.
This recipe gives us the following nice guarantee. If the computation of L is expressed with n computations
expressed through n nodes (and each node computation requires a constant computation time) and m arcs,
13.4. Introduction to Gradient-Based Learning
67
then computing all the partial derivatives ∂L
∂u requires (at most) O(m) computations, using the above recursion (in general, with a bounded in-degree, this is also O(n)). Furthermore, this is a lower bound, i.e., it is
not possible to compute the gradients faster (up to an additive and multiplicative constant).
Note that there are many ways in which to compute these gradients, and whereas the above algorithm is
the fastest one, it is easy to write down an apparently simple recursion that would instead be exponentially
slower, e.g., in O(2n ). In general ∂L
∂u can be written as a sum over all paths in the graph from u to L of the
products of the partial derivatives along each path.
An illustration of this is with a graph with the following structure:
xt = f (xt−1 , yt−1 )
yt = g(xt−1 , yt−1 )
where there are p = n/2 such (xt , yt ) pairs of node, ending with
√ nL = h(xp , yp ) and with input nodes x0
p
n/2
and y0 . The number of paths from x0 to L is 2 = 2
= ( 2) . Note by mental construction how the
number of paths doubles as we increase p by 1.
13.5 Introduction to Multi-Layer Perceptrons (Feedforward Neural
Networks)
13.5.1 Multi-Layer Neural Networks
An MLP (for Multi-Layer Perceptron) or multi-layer neural network defines a family of functions. Let us
first consider the most classical case of a single hidden layer neural network, mapping a d-vector to an
m-vector (e.g. for regression):
g(x) = b + W tanh(c + V x)
where:
• x is a d-vector (the input),
• V is an k × d matrix (called input-to-hidden weights),
• c is a k-vector (called hidden units offsets or hidden unit biases),
• b is an m-vector (called output units offset or output units biases),
• and W is an m × h matrix (called hidden-to-output weights).
The vector-valued function h(x) = tanh(c + V x) is called the output of the hidden layer. Note how the
output is an affine transformation of the hidden layer, in the above network. A non-linearity may be tacked
on to it in some network architectures. The elements of the hidden layer are called hidden units.
The kind of operation computed by the above h(x) can be applied on h(x) itself, but with different parameters (different biases and weights). This would give rise to a feedforward multi-layer network with two
hidden layers. More generally, one can build a deep neural network by stacking more such layers. Each of
these layers may have a different dimension (k above). A common variant is to have skip connections, i.e.,
a layer can take as input not only the layer at the previous level but also some of the lower layers.
68
13.5.2 Most Common Training Criteria and Output Non-Linearities
Let f (x) = r(g(x)) with r representing the output non-linearity function. In supervised learning, the output
f (x) can be compared with a target value y through a loss functional L(f, (x, y)). Here are common loss
functionals, with the associated output non-linearity:
2
• for
P ordinary (L2)2 regression: no non-linearity (r(a) = a), squared loss L(f, (x, y)) = ||f (x) − y|| =
i (fi (x) − yi ) .
• for median
P (L1) regression: no non-linearity (r(a) = a), absolute value loss L(f, (x, y)) = |f (x) −
y|1 = i |fi (x) − yi |.
• for 2-way probabilistic classification: sigmoid non-linearity (r(a) = sigmoid(a) = 1/(1 + e−a ),
applied element by element), and cross-entropy loss L(f, (x, y)) = −y log f (x) − (1 − y) log(1 −
f (x)) for y binary. Note that the sigmoid output f (x) is in the (0,1) interval, and corresponds to an
estimator of P (y = 1|x). The predicted class is 1 if f (x) > 21 .
• for multiple binary probabilistic classification: each output element is treated as above.
• for 2-way hard classification with hinge loss: no non-linearity (r(a) = a) and the hinge loss is
L(f, (x, y)) = max(0, 1 − (2y − 1)f (x)) (again for binary y). This is the SVM classifier loss.
• the above can be generalized to multiple classes by separately considering the binary classifications
of each class against the others.
P
• multi-way probabilistic classification: softmax non-linearity (ri (a) = eai / j eaj with
P one output
per class) with the negative log-likelihood loss L(f, (x, y)) = − log fy (x). Note that i fi (x) = 1
and 0 < fi (x) < 1. Note also how this is equivalent to the cross-entropy loss in the 2-class case (the
output for the one of the classes is actually redundant).
13.5.3 The Back-Propagation Algorithm
We just apply the recursive gradient computation algorithm seen previously to the graph formed naturally by
the MLP, with one node for each input unit, hidden unit and output unit. Note that each parameter (weight
or bias) also corresponds to a node, and the final
Let us formalize a notation for MLPs with more than one hidden layer. Let us denote with hi the output
vector of the i-th layer, starting with h0 = x (the input), and finishing with a special output layer hK which
produces the prediction or output of the network.
With tanh units in the hidden layers, we have (in matrix-vector notation):
• for k = 1 to K − 1:
• hk = tanh(bk + Wk hk−1 )
where bk is a vector of biases and Wk is a matrix of weights connecting layer k − 1 to layer k. The
scalar computation associated with a single unit i of layer k is
P
hk,i = tanh(bk,i + j Wk,i,j hk−1,j )
13.5. Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)
69
In the case of a probabilistic classifier, we would then have a softmax output layer, e.g.,
p = hK = softmax(bK + WK hK−1 )
where we used p to denote the output because it is a vector indicating a probability distribution over classes.
And the loss is
L = − log py
where y is the target class, i.e., we want to maximize py = P (Y = y|x), an estimator of the conditional
probability of class y given input x.
Let us now see how the recursive application of the chain rule in flow graphs is instantiated in this structure.
First of all, let us denote
ak = bk + Wk hk−1
(for the argument of the non-linearity at each level) and note (from a small derivation) that
∂(− log py )
= (pi − 1y=i )
∂aK,i
and that
∂ tanh(u)
= (1 − tanh(u)2 ).
∂u
Now let us apply the back-propagation recipe in the corresponding flow graph. Each parameter (each weight
and each bias) is a node, each neuron potential ak,i and each neuron output hk,i is also a node.
• starting at the output node:
∂L
=1
∂L
• then compute the gradient with respect to each pre-softmax sum aK,i :
∂L
∂L ∂L
=
= (pi − 1y=i )
∂aK,i
∂L ∂aK,i
• We can now repeat the same recipe for each layer. For k = K down to 1:
70
– obtain trivially the gradient wrt biases:
∂L
∂L ∂ak,i
∂L
=
=
∂bk,i
∂ak,i ∂bk,i
∂ak,i
– compute the gradient wrt weights:
∂L
∂L ∂ak,i
∂L
=
=
hk−1,j
∂Wk,i,j
∂ak,i ∂Wk,i,j
∂ak,i
– back-propagate the gradient into lower layer, if k > 1:
X ∂L ∂ak,i
X ∂L
∂L
=
=
Wk,i,j
∂hk−1,j
∂ak,i ∂hk−1,j
∂ak,i
i
i
∂L ∂hk−1,j
∂L
∂L
=
=
(1 − h2k−1,j )
∂ak−1,j
∂hk−1,j ∂ak−1,j
∂hk−1,j
13.5.4 Logistic Regression
Logistic regression is a special case of the MLP with no hidden layer (the input is directly connected to
the output) and the cross-entropy (sigmoid output) or negative log-likelihood (softmax output) loss. It
corresponds to a probabilistic linear classifier and the training criterion is convex in terms of the parameters
(which guarantees that there is only one minimum, which is global).
13.6 Training Multi-Layer Neural Networks
Many algorithms have been proposed to train multi-layer neural networks but the most commonly used ones
are gradient-based.
Two fundamental issues guide the various strategies employed in training MLPs:
• training as efficiently as possible, i.e., getting training error down as quickly as possible, avoiding to
get stuck in narrow valleys or even local minima of the cost function,
• controlling capacity so as to achieve the largest capacity avoids overfitting, i.e., to minimize generalization error.
13.6.1 A fundamentally difficult optimization problem
Optimization of the training criterion of a multi-layer neural network is difficult because there are numerous
local minima. It can be demonstrated that finding the optimal weights is NP-hard. However, we are often
happy to find a good local minimum, or even just a sufficiently low value of the training criterion. Since
what interests us is the generalization error and not just the training error (what we are minimizing is not
13.6. Training Multi-Layer Neural Networks
71
what we would truly like to minimize), the difference between “close to a minimum” and “at a minimum”
is often of no importance. Also, as there is no analytic solution to the minimization problem, we are forced
to perform the optimization in an iterative manner.
13.6.2 Choice of architecture
In principle, one way of accelerating gradient descent is to make choices which render the Hessian matrix
∂2C
∂θi ∂θj well conditioned. The second derivative in a certain direction indicates he curvature of the cost
function in that direction. The larger the curvature (as in narrow valleys), the smaller our updates must be
in order to avoid increasing the error. More precisely, the optimal step size for a gradient step is 1 over the
curvature. This can be seen by a simple Taylor expansion of the cost function, and is behind the famous
optimization algorithm known as Newton’s method. Suppose we are at θk and we wish to choose θk+1 such
that it is a minimum:
C(θk+1 ) = C(θk ) + (θk+1 − θk )C 0 (θk ) + 0.5(θk+1 − θk )2 C 00 (θk )
0=
∂C(θk+1 )
= C 0 (θk ) + (θk+1 − θk )C 00 (θk )
∂θk+1
C 0 (θk )
θk+1 = θk − 00 k
C (θ )
Thus, we want a step size equal to the inverse of the second derivative. One can show that the number
of iterations of a gradient descent algorithm will be proportional to the ratio of the largest to the smallest
eigenvalue of the Hessian matrix (with a quadratic approximation of the cost function). The basic reason is
that the largest eigenvalue limits the maximum step size. One cannot go faster than the highest curvature in
all possible directions, otherwise the error will increase, but if we use the same step size in all directions,
the convergence will be the slowest in the flattest direction (the direction corresponding to the smallest
eigenvalue).
• In theory one hidden layer suffices, but this theorem does not say that this representation of the function will be efficient. In practice, this was the most common choice before 2006, with the exception
of convolutional neural networks (which can have 5 or 6 hidden layers, for example). Sometimes one
obtains much better results with two hidden layers. In fact, we obtain a much better generalization
error with even more layers, but a random initialization does not work well with more than two hidden
layers (but see the work since 2006 on greedy unsupervised initialization for deep architectures).
• For regression or with real-valued targets that are not bounded, it is generally better to use linear
neurons in the output layer. For classification, it is generally better to use neurons with a non-linearity
(sigmoid or softmax) in the output layer.
• In certain cases, direct connections between the input and the output layer can be useful. In the case
of regression, they can also be directly initialized by a linear regression of the outputs on the inputs.
The hidden layer neurons then serve only to learn the missing non-linear part.
• An architecture with shared weights, or sharing certain parts of the architecture (e.g. the first layer)
between networks associated with several related tasks, can significantly improve generalization. See
the following discussion on convolutional networks.
• It is better to use a symmetric nonlinearity in the hidden layers (such as the hyperbolic tangent, or
“tanh”, and unlike the logistic sigmoid), in order to improve the conditioning of the Hessian and avoid
saturation of the nonlinearity in the hidden layers.
72
13.6.3 Normalizing the inputs
It is imperative that the inputs have a mean not too far from zero, and a variance not far from one. Values of
the input must also not be too large in magnitude. If this is not the case, one can perform certain monotonic,
non-linear transformation that reduce large values. If we have a very large input, it will saturate many
neurons and block the learning algorithm for that example. The magnitudes (variances) of inputs to each
layer must also be of the same order when using a single learning rate for all of the layers, in order to avoid
one layer becoming a bottleneck (the slowest to train).
In fact, in the linear case, the Hessian is optimally conditioned when the inputs are normalized (so that the
covariance matrix is the identity), which can be done by projecting into the eigenspace of the matrix X 0 X,
where X is the matrix where xij is input j of training example i.
13.6.4 Preprocessing of the target outputs
In the case of learning by minimizing a quadratic cost function (e.g. mean squared error) it must be assured
that the target outputs
• are always in the interval of values that the nonlinearity in the output layer can produce (and are
roughly normal N(0, 1) in the linear case)
• are not too near to the limits of the nonlinearity in the output layer: for classification, an optimal value
is close to the two inflection points (i.e., the points of maximal curvature/second derivative, -0.6 and
0.6 for tanh, 0.2 and 0.8 for sigmoid).
• It is best to use the cross-entropy criterion (or conditional log likelihood) for probabilistic classification, or the “hinge” margin criterion (as is used for the perceptron and SVMs, but by penalizing
departures from the decision surface beyond a margin). In the case of multiclass classification, this
gives
where x+ = x1x>0 is the “positive part” of x and fi (x) is the output (without a nonlinearity) for class
i.
13.6.5 Coding of target outputs and discrete inputs
With inputs and outputs, we generally represent discrete variables by groups of units (a group of k units for
a discrete variable that can take k values). The practical exception is the case of a binary variable, which
we generally encode with a single unit. In the case of outputs, we will associate with each group a discrete
distribution (binomial for a single bit, multinomial for a general discrete variable).
13.6.6 Optimization algorithms
When the number of examples is large (many thousands) stochastic gradient descent is often the best choice
(especially for classification), in terms of speed and in terms of capacity control: it is more difficult for the
network to overfit when training with stochastic gradient descent. Indeed, stochastic gradient descent does
not fall easily into very sharp minima (which do not generalize well, since a slight perturbation of the data
that changes the error surface will yield very bad performance) due to noise induced by gradient steps and
the “noisy” gradient. This noisy gradient also helps to escape certain local minima for the same reason.
73
When stochastic gradient descent is used, it is critical that the examples be well mixed. For example if
we have many consecutive examples of the same class, the convergence will be very slow. It is enough
to randomly permute the examples once per training session, in oder to eliminate all dependence between
successive examples. With certain architectures that capture temporal dependencies (music, speech, video
or other time series) we have no choice but to present sequences whose elements are highly dependent, but
we can mix up the sequences (the training set is a group of of sequences).
In principle, the gradient step size should be gradually reduced during learning in order to guarantee asymptotic convergence. For certain problems (especially classification), this does not seem necessary, and can
0 τ
even hurt. A reasonable annealing schedule, for example, is t = t+τ
as discussed here. If you could
1
calculate it, the optimal gradient step would be λmax , i.e. the inverse of the largest eigenvalue of the Hessian
matrix, and the maximal step size (before divergence) would be twice as large. Le Cun proposes an efficient
method for estimating λmax (see his tutorial on the subject) but this technique is not often used.
When the number of examples (and thus, of parameters) is very small, especially for regression, second
order methods (often the conjugate gradient method) allow for much faster convergence. These methods
are batch methods (updating parameters only after calculating the error and gradient on all examples). These
techniques are generally easier to use than stochastic gradient descent (there are less hyperparameters, or it
is less necessary to modify them from the default values), but the generalization is often worse because of
the ease with which such methods fall into sharp minima.
Up to several tens of thousands of training examples, conjugate gradient descent remains one of the best optimization techniques for neural networks. Beyond that, it is generally best to stick with stochastic gradient
descent or the minibatch variant thereof.
13.6.7 Parameter initialization
We cannot initialize all the weights to zero without condemning all the hidden units to always computing
the same thing (which can be seen by a simple symmetry argument). We would also like to avoid saturating
units (outputs close to the limits of the non-linearity, such that the gradient is close to zero), while also
avoiding units being too close initially to a linear function. When the parameters are too close to zero, a
multilayer network calculates an affine (linear) transformation, so its effective capacity per output is the
number of inputs plus one. Based on these considerations, the ideal operating regime of a unit would be
close to the inflection point of the nonlinearity (between the linear part of the activation close to the origin
and the saturating part). Also, we would like the average variance of the hidden unit values to be preserved
when we propagate the “activations” from the output to the input, and in the same way we would like the
variance of the gradients to be preserved as we propagate them backwards.
In order to achieve
p this objective,
p it can be argued that the initial weights should be drawn uniformly from
the interval [− 6/(ni + no ), 6/(ni + no )], where ni is the fan-in, i.e., the number of inputs to a neuron
(the number of neurons in the previous layer), and no is the fan-out, i.e., the number of neurons in the
following layer. This supposes that the inputs are approximately uniformly distributed in the interval (-1,1)
(note that the outputs of tanh hidden units fall in the same interval).
13.6.8 Controlling saturation
One frequent problem during learning is the saturation of neurons, often due to a bad normalization of inputs
or target outputs or a bad initialization of weights, or using the logistic signmoid instead of a symmetric
74
nonlinearity such as tanh. This can be controlled by observing the distribution of outputs of neurons (in
particular, the mean of the absolute value of the weighted sum is a good indicator). When the neurons
saturate frequently, learning is blocked on a plateau of the cost function due to the very small gradients on
certain parameters (and thus a very badly conditioned Hessian).
13.6.9 Controlling the effective capacity
Vapnik’s theory of structural risk minimization tells us that there exists an optimal capacity around which the
generalization error increases (i.e. there is a unique, global minimum of generalization error as a function of
model capacity). Techniques for controlling the effective capacity thus seek to find this minimum (obviously
in an approximate fashion):
• early stopping: this is one of the most popular and most efficient techniques, but it does not work
well when the number of examples is very small. The idea is very simple: we use a validation set
of examples held out from training via gradient descent to estimate the generalization error as the
iterative learning proceeds (normally, after each epoch we measure the error on the validation set).
We keep the parameters corresponding to the minimum of this estimated generalization error curve
(and we can stop when this error begins to seriously climb or if a better minimum is not found in a
certain number of epochs). This has the advantage of responding to one of the difficult questions of
optimization, that is: when do we stop? As well, we note that it is a cheap (in terms of computing
time) way to choose an important hyperparameter (number of training iterations) that affects both
optimization and generalization.
• controlling the number of hidden units: This number directly influences the capacity. In this case
we must unfortunately perform several experiments, unless you use a constructive learning algorithm
which adds resources if and when they are needed), see for example the cascade-correlation algorithm
(Fahlman, 1990). We can use a validation set or cross-validation to estimate the generalization error.
One must be careful, as this estimate is noisy (especially if there are few examples in the validation
set). When there are many hidden layers, choosing the same number of hidden units per layer seems
to work well. The price paid in longer computation time for a larger number of hidden units (because
of the increased number of parameters) is generally offset by early stopping. By contrast, when
the number of hidden units is too small, the effect on the generalization error and the training error
can be much larger. We generally choose the size of networks empirically, bearing in mind these
consideration in order to avoid having to try too many different sizes.
• weight decay: This is a regularization method (for controlling capacity, to prevent overfitting) where
the aim is to penalize weights with large magnitude. Indeed, it can be shown that the capacity is
bounded by the magnitude of the weights of a neural network. We add the penalty
X
λ
θi2
i
to the cost function. This is known as L2 regularization, since it minimizes the L2 norm of the
parameters. Sometimes this is applied only to the weights and not to biases.
As in the previous case, we must run several leaning experiments and choose the penalty parameter λ
(a hyperparameter) that minimizes the estimated generalization error. This can be estimated with a
validation set or with cross-validation.
75
A form of regularization that is more and more used as an alternative to L2 regularization is L1
regularization, which has the advantage that small parameters will be shrunk to exactly 0, giving rise
to a sparse vector of parameters. It thus minimizes the sum of the absolute values of the parameters
(the L1 norm).
13.7 The challenges of training deep neural networks
This is a summary of section 4.2 of Learning Deep Architectures for AI.
• Several experimental results show that training neural networks (supervised training from random
initialization) is more difficult when the network is deep (3, 4 or 5 layers) compared to shallow (1
or 2 layers). See Why Does Unsupervised Pre-training Help Deep Learning?. In this regime, the
generalization error is always worse for deep models compared to shallow ones (not the same can be
said about training error). This could very well explain the absence of scientific literature on deep
architectures before 2006 (with the exception of convolutional networks).
• Proposed explications:
– The learning gets stuck into local minima or in a plateau (where due to low curvature the gradients become extremely small; because the weights do not change that much, in this case, it
might seem like the model had already reached a local minima)
– Every layer of a deep network means an extra layer of nonlinearities which increases the chances
of the optimization process to be even more difficult
– In a deep network, one could easily be just learning the top layer, while the lower layers remain
random transformations that do not capture much of the input. This is due to the fact that by
the time the gradients reach the lower layers they are too diluted to be able to guide the learning
process. This view is confirmed by the success of algorithms like the one proposed by Weston
et al. (ICML 2008) which uses additional error signal from solving some unsupervised tasks for
some or all of the intermediate layers. This hypothesis of diluted gradients is also coherent with
the observation that one can train successfully a convolutional deep network.
• While it is clear that pre-training deep networks (using some unsupervised training procedure) helps,
we still have to address the question of why it works? This has been the focus of the paper Why Does
Unsupervised Pre-training Help Deep Learning? and of section 4.2 of Learning Deep Architectures
for AI. The main proposed reasons are:
– The unsupervised pre-training procedure is applied locally at each layer and does not have to
deal with the difficulties of learning deep models. Note that even training Deep Boltzmann
Machines or a Deep Auto-Encoders is difficult and usually requires layer-wise pre-training.
– Unsupervised pre-training behaves like a regularizer, pushing the lower layers towards modelling
the distribution of the input, P (x). The semi-supervised hypothesis says that learning aspects of
P (x) can improve models of the conditional distribution of the target given the input, P (y|x),
because transformations useful for P (x) are useful or closely related to those needed for P (y|x),
i.e. the two distribution share something. Note that, if there are not sufficiently many hidden
units, the regularization can harm by wasting resources on modeling aspects of P (x) which are
not helpful for P (y|x).
76
– It seems that the weights obtained through pre-training lie in a good region of the parameter
space, from where one reaches better local minima through supervised training, compared to
random initialization. The learning trajectory (in the parameter space) also seems quite different
if the model has been pre-trained or randomly initialised.
– A supervised pre-training procedure is worse then an unsupervised one. A reason might be that
supervised pre-training is to greedy, eliminating projections of the data that are not helpful for
the local cost, but are helpful for the global cost of the deep model. This might not happen in the
unsupervised case, because when modeling the input locally, we model all its aspects, not only
those helpful for some local cost.
– Unlike other regularizers, the unsupervised pre-training still has an effect when the number of
training examples grows to be very large, due to its link with non-convex optimization (even
with a lot of examples, starting from a random initialization the reachable local minima are still
worse then those reachable from the pre-trained model).
– One does not deal with an optimization problem in the usual sense because the training error
can be reduced by optimizing only the last layer (and it can even reach 0 if this last layer is
sufficiently large). However, in order to improve the generalize error one needs to be able to
train the lower layers as well. They need to capture all the relevant variations and characteristics
of the input.
– One might need more hidden units when using unsupervised pre-training because most of them
are used to learn features which while they are useful to reconstruct the input, they are not useful
for the discriminative task of classification. Nonetheless a subset of these features are helpful
for classification, and much more so, then those obtained by random initialization.
Version française
13.8 Denoising autoencoders vs. ordinary autoencoders
A denoising autoencoder is like an ordinary autoencoder, with the difference that during learning, the input
seen by the autoencoder is not the raw input but a stochastically corrupted version. A denoising autoencoder
is thus trained to reconstruct the original input from the noisy version. For more information see the article
from ICML 2008: Denoising Auto-Encoders.
Principal differences between ordinary autoencoders and denoising autoencoders:
13.8. Denoising autoencoders vs. ordinary autoencoders
77
Table 13.1: Comparison of ordinary/denoising autoencoder
Ordinary autoencoders
Denoising autoencoders
Finds a compact representation
Capture the joint distribution of
the inputs
Learning criterion
Deterministic
Stochastic
Number of hidden units
Must be limited to avoid learning the
As many as are necessary for
identity function
capturing the distribution
How to choose model
Impossible using standard
Can use the mean reconstruction
capacity (i.e. the number reconstruction error, since it will
error
of hidden units)
always be lower with more hidden units
Choosing the number of
Impossible using reconstruction error:
Can do early stopping using the
learning iterations
use classification error after supervised mean reconstruction error
fine-tuning
Choosing the amount of
not applicable
Cannot use reconstruction error:
corrupting noise
use classification error after
supervised fine-tuning
Aspect
What it does
A more comprehensive article about the Denoising Auto-Encoder, having a long list of experiments:
Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio and Pierre-Antoine Manzagol,
Stacked Denoising Autoencoders: Learning Useful Representations in a Deep Network with a
Local Denoising Criterion (2010), in: Journal of Machine Learning Research, 11:3371–3408
http://www.iro.umontreal.ca/~lisa/publications2/index.php/publications/show/474
Version française
13.9 Probabilistic models for deep architectures
Of particular interest are Boltzmann machine models, certain variants of which are used in deep architectures
such as Deep Belief Networks and Deep Boltzmann Machines. See section 5 of Learning Deep Architectures
for AI.
The Boltzmann distribution is generally defined on binary variables xi ∈ {0, 1}, with
0
0
ex W x+b x
P (x) = P 0
0
x̃ x̃ W x̃ + b x̃
P
where the denominator is simply a normalizing constant such that x P (x) = 1, and the Wij indicates the
nature of the interaction (e.g. a positive value indicates that xi et xj prefer to take the same value) between
pairs of variables, and bi indicates the inclination of a given xi to take a value of 1.
13.9.1 Readings on probabilistic graphical models
See
Graphical models: probabilistic inference. M. I. Jordan and Y. Weiss. In M. Arbib (Ed.), The Handbook of
Brain Theory and Neural Networks, 2nd edition. Cambridge, MA: MIT Press, 2002.
78
Certain distributions can be written P (x) for a vector of variables x = (x1 , x2 , . . .) in the form
P (x) =
1 Y
ψc (xc )
Z c
where Z is the normalizing constant (called the partition function), and the product is over cliques (subsets
xc of elements of the vector x), and the ψc (.) are functions (one per clique) that indicate how the variables
in each clique interact.
A particular case where Z may be simplified a bit (factorized over cliques) is the case of directed models
where variables are structured as a directed acyclic graph, with a topological ordering that associates a group
of parent variables parents(xi ) with each variable xi :
Y
P (x) =
Pi (xi |parents(xi ))
i
where it can be seen that there is one clique for a variable and its parents, i.e., Pi (xi |parents(xi )) =
ψi (xi , parents(xi ))/Zi .
In the general case (represented with an undirected graph), the potential functions ψc are directly parameterized, often in the space of logarithms of ψc , leading to a formulation known as a Markov random
field:
P (x) =
1 − Pc Ec (xc )
e
Z
where:math:E(x)=sum_c E_c(x_c) is called the energy function. The energy function of a Boltzmann
machine is a second degree polynomial in x. The most common parameterization of Markov random fields
has the following form, which is log-linear:
P (x) =
1 − Pc θc fc (xc )
e
Z
where the only free parameters are the θc , and where the complete log likelihood (when x is completely
observed in each training example) is log-linear in the parameters θ. One can easily show that this function
is convex in θ.
13.9.2 Inference
One of the most important obstacles in the practical application of the majority of probabilistic models is the
difficulty of inference: given certain variables (a subset of x), predict the marginal distribution (separately
for each) or joint distribution of certain other variables. Let x = (v, h) with h (hidden) being the variables
we would like to predict, and v (visible) being the observed subset. One would like to calculate, or at least
sample from,
P (h|v).
13.9. Probabilistic models for deep architectures
79
Inference is obviously useful if certain variables are missing, or if, while using the model, we wish to predict
a certain variable (for example the class of an image) given some other variables (for example, the image
itself). Note that if the model has hidden variables (variables that are never observed in the data) we do not
try to predict the values directly, but we will still implicitly marginalize over these variables (sum over all
configurations of these variables).
Inference is also an essential component of learning, in order to calculate gradients (as seen below in the
case of Boltzmann machines) or in the use of the Expectation-Maximization (EM) algorithm which requires
a marginalization over all hidden variables.
In general, exact inference has a computational cost exponential in the size of the cliques of a graph (in
fact, the unobserved part of the graph) because we must consider all possible combinations of values of the
variables in each clique. See section 3.4 of Graphical models: probabilistic inference for a survey of exact
inference methods.
A simplifed form of inference consists of calculating not the entire distribution, but only the mode (the most
likely configuration of values) of the distribution:
h∗ = argmaxh P (h|v)
This is known as MAP = Maximum A Posteriori inference.
13.9.3 Approximate inference
The two principal families of methods for approximate inference in probabilistic models are Markov chain
Monte Carlo (MCMC) methods and variational inference.
The principle behind variational inference is the following. We will define a simpler model than the target
model (the one that interests us), in which inference is easy, with a similar set of variables (though generally with more simple dependencies between variables than those contained in the target model). We then
optimize the parameters of the simpler model so as to approximate the target model as closely as possible. Finally, we do inference using the simpler model. See section 4.2 of Graphical models: probabilistic
inference for more details and a survey.
13.9.4 Inference with MCMC
In general P (h|v) can be exponentially expensive to represent (in terms of the number of hidden variables,
because we must consider all possible configurations of h). The principle behind Monte Carlo inference is
that we can approximate the distribution P (h|v) using samples from this distribution. Indeed, in practice we
only need an expectation (for example, the expectation of the gradient) under this conditional distribution.
We can thus approximate the desired expectation with an average of these samples.
See the page site du zéro sur Monte-Carlo (in French) for a gentle introduction.
Unfortunately, for most probabilistic models, even sampling from P (h|v) exactly is not feasible (taking time
exponential in the dimension of de h). Therefore the most general approach is based on an approximation
of Monte-Carlo sampling called Markov chain Monte Carlo (MCMC).
80
A (first order) Markov chain is a sequence of random variables Z1 , Z2 , . . ., where Zk is independent of
Zk−2 , Zk−3 , . . . given Zk−1 :
P (Zk |Zk−1 , Zk−2 , Zk−3 , . . .) = P (Zk |Zk−1 )
n
Y
P (Z1 . . . Zn ) = P (Z1 )
P (Zk |Zk−1 )
k=2
The goal of MCMC is to construct a Markov chain whose asymptotic marginal distribution, i.e. the distribution of Zn as n → ∞, converges towards a given target distribution, such as P (h|v) or P (x).
13.9.5 Gibbs sampling
Numerous MCMC-based sampling methods exist. The one most commonly used for deep architectures is
Gibbs sampling. It is simple and has a certain plausible analogy with the functioning of the brain, where
each neuron decides to send signals with a certain probability as a function of the signals it receives from
other neurons.
Let us suppose that we wish to sample from the distribution P (x) where x is a set of variables xi (we could
optionally have a set of variables upon which we have conditioned, but this would not change the procedure,
so we ignore them in the following description).
Let x−i = (x1 , x2 , . . . , xi−1 , xi+1 , . . . , xn ), i.e. all variables in x excluding xi . Gibbs sampling is performed using the following algorithm:
• Choose an initial value of x in an arbitrary manner (random or not)
• For each step of the Markov chain:
– Iterate over each xk in x
* Draw xk from the conditional distribution P (xk |x−k )
In some cases one can group variables in x into blocks or groups of variables such that drawing samples for
an entire group, given the others, is easy. In this case it is advantageous to interpret the algorithm above with
xi as the ith group rather than the ith variable. This is known as block Gibbs sampling.
13.9.6 The gradient in a log-linear Markov random field
See Learning Deep Architectures for AI for detailed derivations.
Log-linear Markov random fields are undirected probabilistic models where the energy function is linear in
the parameters θ of the model:
P (x) ∝ e−
P
i θi fi (x)
where fi (.) are known as sufficient statistics of the model, because the expectations E[fi (x)] are sufficient
for characterizing the distribution and estimating parameters.
Note that eθi fi (x) = ψi (x) is associated with each clique in the model (in general, only a sub-vector of x
influences each fi (x)).
13.9. Probabilistic models for deep architectures
81
Getting back to sufficient statistics, one can show that the gradient of the log likelihood is as follows:
X
−∂ log P (x)
= fi (x) −
P (x)fi (x)
∂θi
x
and the average gradient over training examples xt is thus
X
1 X −∂logP (xt )
1X
P (x)fi (x)
=
fi (xt ) −
T t
∂θi
T t
x
Thus, it is clear that the gradient vanishes when the average of the sufficient statistics under the training
distribution equals their expectation under the model distribution :math:‘P‘.
Unfortunately, calculating this gradient is difficult. We do not want to sum over all possible x, but fortunately
one can obtain a Monte-Carlo approximation by one or more samples from P (x), which gives us a noisy
estimate of the gradient. In general, however, even to obtain an unbiased sample from P (x) is exponentially
costly, and thus one must use an MCMC method.
We refer to the terms of the gradient due to the numerator of the probability density (−fi (x)) as the ‘positive
phase’ gradient, and the terms of the gradient corresponding to the partition function (denominator of the
probability density) as the ‘negative phase’ gradient.
13.9.7 Marginalization over hidden variables
When a model contains hidden variables, the gradient becomes a bit more complicated since one must
marginalize over the hidden variables. Let x = (v, h), with v being the visible part and h being the hidden
part, with statistics from functions of the two, fi (v, h). The average gradient of the negative log likelihood
of the observed data is thus
X
1 X −∂ log P (vt )
1 XX
=
P (h|vt )fi (vt , h) −
P (v, h)fi (v, h).
T t
∂θi
T t
h
h,v
In the general case, it will be necessary to resort to MCMC not only for the negative phase gradient but also
for the positive phase gradient, i.e. to sample P (v|ht ).
13.10 The Boltzmann Machine
A Boltzmann machine is an undirected probabilistic model, a particular form of log-linear Markov random
field, containing both visible and hidden variables, where the energy function is a second degree polynomial
of the variables x:
E(x) = −d0 x − x0 Ax
82
The classic Boltzmann machine has binary variables and inference is conducted via Gibbs sampling, which
requires samples from P (xi |x−i ). It can be easily shown that
P (xi = 1|x−i ) = sigmoid(di + ωi x−i )
where ωi is the ith row of A excluding the ith element (the diagonal of A is 0 in this model). Thus, we see
the link with networks of neurons.
13.10.1 Restricted Boltzmann Machines
A Restricted Boltzmann Machine, or RBM, is a Boltzmann machine without lateral connections between
the visible units vi or between the hidden units hi . The energy function thus becomes
E(v, h) = −b0 h − c0 v − v 0 W h.
where the matrix A is entirely 0 except in the submatrix W . The advantage of this connectivity restriction is that inferring P (h|v) (and also P (v|h)) becomes very easy, can be performed analytically, and the
distribution factorizes:
Y
P (h|v) =
P (hi |v)
i
and
P (v|h) =
Y
P (vi |h)
i
In the case where the variables (“units”) are binary, we obtain once again have a sigmoid activation probability:
X
P (hj = 1|v) = sigmoid(bj +
Wij vi )
i
P (vi = 1|h) = sigmoid(ci +
X
Wij hj )
j
Another advantage of the RBM is that the distribution P (v) can be calculated analytically up to a constant
(the unknown constant being the partition function). This permits us to define a generalization of the notion
of an energy function in the case when we wish to marginalize over the hidden variables: the free energy
(inspired by notions from physics)
P −E(v,h)
e
e−F E(v) X
=
P (v, h) = h
P (v) =
Z
Z
h
X
F E(v) = − log
e−E(v,h)
h
13.10. The Boltzmann Machine
83
and in the case of RBMs, we have
F E(v) = −b0 v −
X
log
i
X
0
ehi (ci +v W.i )
hi
where the sum over hi is a sum over values that the hidden variables can take, which in the case of binary
units yields
X
0
F E(v) = −b0 v −
log(1 + eci +v W.i )
i
0
F E(v) = −b v −
X
softplus(ci + v 0 W.i )
i
13.10.2 Gibbs sampling in RBMs
Although sampling from P (h|v) is easy and immediate in an RBM, drawing samples from P (v) or from
P (v, h) cannot be done exactly and is thus generally accomplished with MCMC, most commonly with block
Gibbs sampling, where we take advantage of the fact that sampling from P (h|v) and P (v|h) is easy:
v (1) ∼ exemple d0 apprentissage
h(1) ∼ P (h|v (1) )
v (2) ∼ P (v|h(1) )
h(2) ∼ P (h|v (2) )
v (3) ∼ P (v|h(2) )
...
(k)
In order to visualize the generated data at step k, it is better to use expectations (i.e. E[vi |h(k−1) ] =
(k)
P (vi = 1|h(k−1) )) which are less noisy than the samples v (k) themselves.
13.11 Training RBMs
The exact gradient of the parameters of an RBM (for an example v) is
∂ log P (v)
= v 0 E[h|v] − E[v 0 h]
∂W
∂ log P (v)
= E[h|v] − E[h]
∂b
∂ log P (v)
= v − E[v]
∂c
where the expectations are under the distribution of the RBM. The conditional expectations can be calculated
analytically (since E[hi |v] = P (hi = 1|v) = the output of a hidden unit, for binary hi ) but the unconditional
expectations must be approximated using MCMC.
84
13.11.1 Contrastive Divergence
The first and simplest approximation of E[v 0 h], i.e., for obtaining ‘negative examples’ (for the ‘negative
phase’ gradient), consists of running a short Gibbs chain (of k steps) beginning at a training example. This
algorithm is known as CD-k (Contrastive Divergence with k steps). See algorithm 1 in Learning Deep
Architectures for AI:
0
0
W ← W + (v (1) ĥ(1) − v (2) ĥ(2) )
b ← b + (ĥ(1) − ĥ(2) )
c ← c + (v (1) − v (2) )
where is the gradient step size, and we refer to the notation for Gibbs sampling from RBMs above, with
(1)
(2)
(2)
ĥ(1) denotes the vector of probabilities P (hi = 1|v1 ) and in the same fashion ĥi = P (hi = 1|v (2) ).
What is surprising is that even with k = 1, we obtain RBMs that work well in the sense that they extract good
features from the data (which we can verify visually byt looking at the filters, the stochastic reconstructions
after one step of Gibbs, or quantitatively by initializing each layer of a deep network with W and b obtained
by pretraining an RBM at each layer).
It can be shown that CD-1 is very close to the training procedure of an autoencoder by minimizing reconstruction error, and one can see that the reconstruction error diminishes in a mostly monotonic fashion
during CD-1 training.
It can also be shown that CD-k tends to the true gradient (in expected value) when k becomes large, but at
the same time increases computation time by a factor of k.
13.11.2 Persistent Contrastive Divergence
In order to obtain a less biased estimator of the true gradient without significantly increasing the necessary
computation time, we can use the Persistent Contrastive Divergence (PCD) algorithm. Rather than restarting
a Gibbs chain after each presentation of a training example v, PCD keeps a chain running in order to obtain
negative examples. This chain is a bit peculiar because its transition probabilities change (slowly) as we
update the parameters of the RBM. Let v − , h− be the state of our negative phase chain. The learning
algorithm is then
ĥi = P (hi = 1|v)
∀i, v̂i− = P (vi = 1|h− )
v − ∼ v̂ −
−
∀i, hbi = P (hi = 1|v − )
h− ∼ ĥ−
0
W ← W + (v ĥ0 − v − ĥ− )
b ← b + (ĥ − ĥ− )
c ← c + (v − v̂ − )
Experimentally we find that PCD is better in terms of generating examples that resemble the training data
(and in terms of the likelihood log P (v)) than CD-k, and is less sensitive to the initialization of the Gibbs
chain.
13.11. Training RBMs
85
13.12 Stacked RBMs and DBNs
RBMs can be used, like autoencoders, to pretrain a deep neural network in an unsupervised manner, and
finish training in the usual supervised fashion. One stacks RBMs with the hidden layer of one (given its
input) i.e., les P (h|v) or h ∼ P (h|v), becomes the data for the next layer.
The pseudocode for greedy layer-by-layer training of a stack of RBMs is presented in section 6.1 (algorithm
2) of Learning Deep Architectures for AI. To train the k th RBM, we propagate forward samples h ∼ P (h|v)
or the posteriors P (h|v) through the k − 1 previously trained RBMs and use them as data for training the
k th RBM. They are trained one at a time: once we stop training the k th , we move on to the k + 1th .
An RBM has the same parameterization as a layer in a classic neural network (with logistic sigmoid hidden
units), with the difference that we use only the weights W and the biases b of the hidden units (since we
only need P (h|v) and not P (v|h)).
13.12.1 Deep Belief Networks
We can also consider a stacking of RBMs in a generative manner, and we call these models Deep Belief
Networks:
!
`−2
Y
P (x, h1 , . . . , h` ) =
P (hk |hk+1 ) P (h`−1 , h` )
k=0
where we denote x = h0 and hk as the random variable (vector) associated with layer k. The last two
layers have a joint distribution given by an RBM (the last of the stack). The RBMs below serve only to
define the conditional probabilities P (hk |hk+1 ) of the DBN, where hk play the role of visible units and
:math:‘h^{k+1}‘similarly play the role of hidden units in RBM k+1.
Sampling from a DBN is thus performed as follows:
• Sample a h`−1 from the top RBM (number `), for example by running a Gibbs chain
• For k from ` − 1 to 1
– sample the visible units (hk ) given the hidden units (hk+1 ) in RBM k
• Return hk , the last sample obtained, which is the result of generating from the DBN
13.12.2 Unfolding an RBM and RBM - DBN equivalence
It can be shown (see section 8.1 of Learning Deep Architectures for AI.) that an RBM corresponds to DBN
with a particular architecture, where the weights are shared between all the layers: level 1 of the DBN uses
the weights W of the RBM, level 2 uses the weights W 0 , level 3 uses W , etc. alternating between W and
W 0 . The last pair of layers of the DBN is an RBM with weights W or :math‘W’‘ depending on whether
the number of layers is odd or even. Note that in this equivalence, the DBN has layer sizes that alternate
(number of visible units of the RBM, number of hidden units of the RBM, number of visible units, etc.)
In fact we can continue the unfolding of an RBM infinitely and obtain an infinite directed network with
shared weights, equivalently. See figure 13 in the same section, 8.1.
86
It can be seen that this infinite network corresponds exactly to an infinite Gibbs chain that leads to (finishes
on) the visible layer of the original RBM, i.e. that generates the same examples. The even layers correspond
to sampling P (v|h) (of the original RBM) and the odd layers to sampling P (h|v).
Finally, it can be shown that if we take an RBM and unfold it one time (mirrored), the continued training
of the new RBM on top (initialized with W 0 ) maximizes a lower bound on the log likelihood of the corresponding DBN. In passing from an RBM to a DBN, we replace the marginal distribution P (h) of the RBM
(which is encoded implicitly in the parameters of the RBM) with the distribution generated by the part of
the DBN above this RBM (the DBN consists of all layers above h), since this h corresponds to visible units
of this DBN. The proof is simple and instructive, and uses the letter Q for the probabilities according to the
RBM (at the bottom) and the letter P for the probabilities according to the DBN obtained by modeling h
differently (i.e. by replacing Q(h) by P (h)). We also remark that P (x|h) = Q(x|h), but this is not true for
P (h|x) and Q(h|x).
!
X
X
P (x, h)
log P (x) =
Q(h|x) log P (x) =
Q(h|x) log
P (h|x)
h
h
X
P (x, h) Q(h|x)
log P (x) =
Q(h|x) log
P (h|x) Q(h|x)
h
X
X
Q(h|x)
log P (x) = HQ(h|x) +
Q(h|x) log P (x, h) +
Q(h|x) log
P (h|x)
h
h
X
log P (x) = KL(Q(h|x)||P (h|x)) + HQ(h|x) +
h
log P (x) ≥
X
h
This shows that one can actually increase the lower bound (last line) by doing maximum likelihood training
of P (h) using as training data the h drawn from Q(h|x), where x is drawn from the training distribution of
the bottom RBM. Since we have decoupled the weights below from those above, we don’t touch the bottom
RBM (P (x|h) and Q(h|x)), and only modify P (h).
13.12.3 Approximate inference in DBNs
Contrary to the RBM, inference in DBNs (inferring the states of the hidden units given the visible units) is
very difficult. Given that we initialize DBNs as a stack of RBMs, in practice the following approximation is
used: sample the hk given the hk−1 using the new weights of level k. This would be exact inference if this
was still an isolated RBM, but it is no longer exact with the DBN.
We saw that this is an approximation in the previous section because the marginal P (h) (of the DBN) differs
from the marginal Q(h) (of the bottom RBM), after modifying the upper weights so that they are no longer
the transpose of the bottom weights, and thus P (h|x) differs from Q(h|x).
13.12.4 Deep Boltzmann Machines
Finally, we can also use a stack of RBMs for initializing a deep Boltzmann machine (Salakhutdinov and
Hinton, AISTATS 2009). This is a Boltzmann machine organized in layers, where each layer is connected
the layer below and the layer above, and there are no within-layer connections.
13.12. Stacked RBMs and DBNs
87
Note that the weights are somehow two times too big when doing the initialization described above, since
now each unit receives input from the layer above and the layer below, whereas in the original RBM it
was either one or the other. Salakhutdinov proposes thus dividing the weights by two when we make the
transition from stacking RBMs to deep Boltzmann machines.
It is also interesting to note that according to Salakhutdinov, it is crucial to initialize deep Boltzmann machines as a stack of RBMs, rather than with random weights. This suggests that the difficulty of training
deep deterministic MLP networks is not unique to MLPs, and that a similar difficulty is found in deep Boltzmann machines. In both cases, the initialization of each layer according to a local training procedure seems
to help a great deal. Salakhutdinov obtains better results with his deep Boltzmann machine than with an
equivalent-sized DBN, although training the deep Boltzmann machine takes longer.
88

Notes de cours - Département d`informatique et de recherche

Transcription

Documents pareils

Offre de Stage de PFE « Deep Reinforcement Learning Techniques

Ingénieur Chercheur en Vision par Ordinateur et Deep - CEA-List

Kramnik VS Deep Fritz : Game 1

comprendre et intégrer la démarche marketing

Reconnaissance des émotions faciales par analyse vidéo

INSA – GMM-MMN 5 Image Travaux pratiques Feuille 3 : Zoom d

Guide de la campagne ULM 2015 - Ministère de l`écologie et du

Le gradient d`une fonction scalaire

Liste des domaines cibles de l`agenda pour l`éducation post 2015

ÉCOUTER POUR MIEUX COMMUNIQUER