Null

Notes de cours IFT6266 H10
Release 31.03.2010
Université de Montréal, DIRO
April 02, 2010

CONTENTS
1 IFT6266: Plan de chaque cours 1

1.1 31 Mars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 29 Mars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 24 Mars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 22 Mars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 17 Mars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.6 15 Mars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.7 10 Mars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.8 8 Mars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.9 24 Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.10 22 Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.11 17 Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.12 15 Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.13 12 Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.14 10 Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.15 8 Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.16 3 Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.17 1er Février . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.18 27 Janvier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.19 25 Janvier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.20 20 Janvier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.21 18 Janvier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.22 13 Janvier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.23 11 Janvier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.24 6 Janvier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2 Very Brief Introduction to Machine Learning for AI 9

2.1 Intelligence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Artificial Intelligence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4 Formalization of Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.5 Supervised Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.6 Unsupervised Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.7 Local Generalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
i
2.8 Distributed versus Local Representation and Non-Local Generalization . . . . . . . . . . . 11
3 Introduction to Deep Learning Algorithms 13

3.1 Depth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2 Motivations for Deep Architectures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3 Insufficient depth can hurt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4 The brain has a deep architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.5 Cognitive processes seem deep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.6 Breakthrough in Learning Deep Architectures . . . . . . . . . . . . . . . . . . . . . . . . . 15
4 Introduction to Gradient-Based Learning 17

4.1 The Gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2 Gradient Descent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3 Stochastic Gradient Descent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.4 Minibatch Stochastic Gradient Descent . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.5 Momentum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.6 Choosing the Learning Rate Schedule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.7 Flow Graphs, Chain Rule and Backpropagation: Efficient Computation of the Gradient . . . 20
5 Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks) 23

5.1 Multi-Layer Neural Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.2 Most Common Training Criteria and Output Non-Linearities . . . . . . . . . . . . . . . . . 23
5.3 The Back-Propagation Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.4 Logistic Regression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6 Training Multi-Layer Neural Networks 27

6.1 Problème fondamentalement difficile d’optimisation . . . . . . . . . . . . . . . . . . . . . 27
6.2 Choix de l’architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.3 Normalisation des entrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.4 Traitement des sorties désirées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.5 Codage des sorties désirées et des entrées discrètes . . . . . . . . . . . . . . . . . . . . . . 29
6.6 Algorithme d’optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.7 Initialisation des paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
6.8 Contrôle de la saturation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
6.9 Contrôle de la capacité effective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7 Le défi d’entraîner des réseaux de neurones profonds 33
8 Auto-encodeurs débruitants vs auto-encodeurs ordinaires 35
9 Modèles probabilistes pour les architectures profondes 37

9.1 Rappels sur les modèles graphiques probabilistes . . . . . . . . . . . . . . . . . . . . . . . 37
9.2 Inférence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.3 Inférence approximative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
9.4 Inférence par MCMC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
9.5 Échantillonage de Gibbs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
9.6 Le Gradient dans un Champs de Markov Log-Linéaire . . . . . . . . . . . . . . . . . . . . 40
9.7 Marginalisation sur les variables cachées . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
ii
10 La Machine de Boltzmann 43
10.1 La Machine de Boltzmann Restreinte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
10.2 Gibbs dans les RBMs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
11 Entraînement des RBMs 45

11.1 Divergence Contrastive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.2 Divergence Contrastive Persistente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12 RBMs empilés et DBNs 47

12.1 Deep Belief Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
12.2 Dépliement d’une RBM et équivalence RBM - DBN . . . . . . . . . . . . . . . . . . . . . 48
12.3 Inférence approximative dans les DBNs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
12.4 Deep Boltzmann Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
iii
iv
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)
1
Notes de cours IFT6266 H10, Release 31.03.2010
Date Sujets À lire en priorité

31 Révision Toutes les notes de cours.
mars
29 DBNs RBMs empilés et DBNs
mars
24 2 articles AISTATS
mars
22 DBNs RBMs empilés et DBNs
mars
17 RBMs en Theano Tutorial sur les RBMs en Theano.
mars
15 RBMs, entraînement Section 5 de Learning Deep Architectures for AI.
mars Entraînement des RBMs.
10 RBMs Section 5 de Learning Deep Architectures for AI. Intro à La
mars Machine de Boltzmann Restreinte. Entraînement des RBMs.
8 Gibbs et RBMs Section 5 de Learning Deep Architectures for AI. Intro à La
mars Machine de Boltzmann Restreinte.
24 Inférence et MCMC Intro aux Modèles probabilistes pour les architectures
février profondes.
22 Modèles probabilistes Intro aux Modèles probabilistes pour les architectures
février profondes.
17 Entraînement profond Le défi d’entraîner des réseaux de neurones profonds.
février
15 Auto-encodeurs empilés Denoising Auto-Encoders
février
12 Auto-encodeurs Tutoriel sur les auto-encodeurs débruitants
février
10 Auto-encodeurs Section 4.6 de Learning Deep Architectures for AI
février
8 Réseaux à convolution Tutoriel sur les réseaux à convolution,
février
3 Réseaux à convolution Neocognitron et LeNet.
février Journal d’expérience Exemple de journal d’expérience.
Réseaux à délais Time-Delay Neural Networks <Time-Delay Neural Networks
1er Entraînement des MLPs Training Multi-Layer Neural Networks.
février Jobman Documentation de Jobman.
Réseaux à convolution Neocognitron et LeNet.
27 python, numpy, Theano Documentation sur python, numpy, et Theano.
jan- DeepLearningTutorial Exemple avec la Régression logistique. Notes sur
vier l’entraînement des MLPs.
25 python, numpy, Theano Documentation sur python, numpy, et Theano.
jan- Régression logistique Exemple avec la Régression logistique. Notes sur
vier l’entraînement des MLPs.
20 Réseaux de neurones Efficient Backprop.
jan- Intro au tutorial profond de Theano. Démarrage du tutoriel.
vier
18 Le calcul du gradient Notes sur le calcul du gradient.
jan-
vier
213 Le gradient Notes sur le gradient.
Chapter 1. IFT6266: Plan de chaque cours
jan-
vier
11 Intro aux architectures Notes introductoires sur les architectures profondes, Sec. 1 de
1.1 31 Mars
• Révision en vue de l’examen final
1.2 29 Mars
• RBMs empilés et DBNs

• Révision en vue de l’examen final
1.3 24 Mars
2 présentations d’articles de AISTATS 2010:

• Guillaume Desjardins: Parallel Tempering for Training of Restricted Boltzmann Machines
• Xavier Glorot: Understanding the difficulty of training deep feedforward neural networks
1.4 22 Mars
• Intro aux RBMs empilés et DBNs
1.5 17 Mars
• Tutorial sur les RBMs en Theano
1.6 15 Mars
• Entraînement des RBMs. Contrastive divergence et PCD. Section 5 de Learning Deep Architectures
for AI
1.7 10 Mars
• La Machine de Boltzmann Restreinte. Gradient dans les MRFs et les RBMs. Gibbs dans les machines
de Boltzmann et les RBMs. Section 5 de Learning Deep Architectures for AI
1.8 8 Mars
• Champs markoviens, machine de Boltzmann et RBMs. La Machine de Boltzmann Restreinte. Section

5 de Learning Deep Architectures for AI
1.1. 31 Mars 3
1.9 24 Février
• MCMC et Gibbs
• Inférence dans les modèles probabilistes
1.10 22 Février
• Intro aux Modèles probabilistes pour les architectures profondes.

• Modèles probabilistes graphiques: matière préparatoire pour les RBMs et DBNs.
1.11 17 Février
• Résumé des Auto-encodeurs débruitants vs auto-encodeurs ordinaires

• Difficulté d’entraîner des architectures profondes. Section 4.2 de Learning Deep Architectures for AI,
et le résumé sur Le défi d’entraîner des réseaux de neurones profonds.
• Pré-entraînement non-supervisé couche par couche et ajustement supervisé. Section 6 de Learning
Deep Architectures for AI
1.12 15 Février
• Auto-encodeurs débruitants empilés

– Présentation de Pascal Vincent sur les auto-encodeurs débruitants
– Article original sur les Denoising Auto-Encoders
1.13 12 Février
• Auto-encodeurs et auto-encodeurs débruitants

– Survol des auto-encodeurs: section 4.6 de Learning Deep Architectures for AI
– Tutorial sur les auto-encodeurs débruitants
1.14 10 Février
• Auto-encodeurs
– Survol des auto-encodeurs: section 4.6 de Learning Deep Architectures for AI
4 Chapter 1. IFT6266: Plan de chaque cours

1.15 8 Février
• Fin de la discussion sur les réseaux à convolution * Tutoriel sur les réseaux à convolution pour Theano
• Auto-encodeurs * Survol des auto-encodeurs: section 4.6 de Learning Deep Architectures for AI
1.16 3 Février
• Réseaux à convolution
– LeNet
– Time-Delay Neural Networks
• Comment faire un journal d’expérience
• Discussion sur les tickets et le projet
1.17 1er Février
• Intro à Jobman pour céduler et organiser des jobs d’expériences, et exemple d’utilisation avec les
MLPs
– Présentation de Dumitru Erhan sur Jobman.
• Suite de l’entraînement des réseaux de neurones et choix des hyper-paramètres (Training Multi-Layer
Neural Networks)
• Intro aux réseaux à convolution
– Néocognitron
– LeNet
– Tutoriel sur les réseaux à convolution pour Theano
1.18 27 Janvier
• Introduction à mercurial pour la gestion des révisions de code, présentation de Dumitru Erhan
• Suite de l’entraînement des réseaux de neurones:
– Arrêt prématuré (early stopping): Training Multi-Layer Neural Networks
• Réponses aux questions sur python, numpy, et Theano.
• Démarrage du tutorial profond de Theano
• Exemple sur la régression logistique en Theano.
1.15. 8 Février 5
1.19 25 Janvier
• Suite de l’entraînement des réseaux de neurones:

– The Back-Propagation Algorithm
– Logistic Regression
– Training Multi-Layer Neural Networks
• Plan de travail pour les premières semaines du projet. Discussions sur les transformations des images
pour générer plus de variations et produire un classifieur plus robuste à toutes sortes de bruits et de
variations.
1.20 20 Janvier
• Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)

– Most Common Training Criteria and Output Non-Linearities
• Discussion sur les objectifs et le cadre du projet
• Introduction à Theano
• Intro au tutoriel profond de Theano
1.21 18 Janvier
• Flow Graphs, Chain Rule and Backpropagation: Efficient Computation of the Gradient
• Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)
– Multi-Layer Neural Networks
– Most Common Training Criteria and Output Non-Linearities
1.22 13 Janvier
• Introduction to Gradient-Based Learning

– The Gradient
– Gradient Descent
– Stochastic Gradient Descent
– Minibatch Stochastic Gradient Descent
– Momentum
– Choosing the Learning Rate Schedule

1.23 11 Janvier
• Introduction to Deep Learning Algorithms

– Depth
– Motivations for Deep Architectures
– Insufficient depth can hurt
– The brain has a deep architecture
– Cognitive processes seem deep
– Breakthrough in Learning Deep Architectures
1.24 6 Janvier
• Introduction au cours, objectifs du cours, modalités d’évaluation (plan de cours)

• Very Brief Introduction to Machine Learning for AI
– Intelligence
– Artificial Intelligence
– Machine Learning
– Formalization of Learning
– Supervised Learning
– Unsupervised Learning
– Local Generalization
– Distributed versus Local Representation and Non-Local Generalization
1.23. 11 Janvier 7

CHAPTER
TWO
VERY BRIEF INTRODUCTION TO

MACHINE LEARNING FOR AI
The topics summarized here are covered in these slides.
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.
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.
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:
• Chris Bishop, “Pattern Recognition and Machine Learning”, 2007
9
• 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.
2.4 Formalization of Learning
First, let us formalize the most common mathematical framework for learning. We are given training exam-
ples
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).
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

X
fY (X) ≥ 0 , fi (X) = 1
i
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
10 Chapter 2. Very Brief Introduction to Machine Learning for AI

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.
2.7 Local Generalization
The vast majority of learning algorithms exploit a single principle for achieving generalization: local gen-
eralization. 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. 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.
2.8 Distributed versus Local Representation and Non-Local General-

ization
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 log2 B 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 represen-
tations 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 distin-
guishable 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 di-
rections, 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
2.7. Local Generalization 11

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).
12 Chapter 2. Very Brief Introduction to Machine Learning for AI

CHAPTER
THREE
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
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
(one for the kernel outputs or for the feature space, and one for the linear combination producing the output).
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
13
• Cognitive processes seem deep
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 repre-
sented 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
structure exists in the underlying function to be represented. If there was no structure whatsoever, it would
not be possible to generalize well.
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.
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 intro-
spection?). 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).
14 Chapter 3. Introduction to Deep Learning Algorithms

3.6 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 Compu-
tation 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.
Since 2006, a plethora of other papers on the subject of deep learning has been published, some of them ex-
ploiting other principles to guide training of intermediate representations. See Learning Deep Architectures
for AI for a survey.
3.6. Breakthrough in Learning Deep Architectures 15

16 Chapter 3. Introduction to Deep Learning Algorithms

CHAPTER
FOUR
INTRODUCTION TO GRADIENT-BASED
LEARNING
Consider a cost function C which maps a parameter vector θ to a scalar C(θ) which we would like to mini-
mize. In machine learning the cost function is typically the average or the expectation of a loss functional:
n
1X
C(θ) = 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.
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.
When θ is a vector, the gradient ∂C(θ) ∂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 .
17
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
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:
∂C(θk )
θk+1 = θk − 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.
4.3 Stochastic Gradient Descent
We exploit the fact that C is an average, generally over i.i.d. (independently and identically distributed) ex-
amples, to make updates to θ much more often, in the extreme (and most common) case after each example:
∂L(θk , z)
θk+1 = θk − k
∂θ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).
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
18 Chapter 4. Introduction to Gradient-Based Learning

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).
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.,
∂L(θk , z)
∆θk+1 = α∆θk + (1 − α)
∂θk
where α is a hyper-parameter that controls the how much weight is given in this average to older vs most
recent gradients.
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 (Hes-
sian) 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
4.5. Momentum 19
∞
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.
4.7 Flow Graphs, Chain Rule and Backpropagation: Efficient Compu-

tation 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 (those
nodes vi taking the value computed at u as input). 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 .
∂L
The chain rule for derivatives specifies how the partial derivative ∂u for a node u can be obtained recur-
∂L
sively from the partial derivatives ∂v i
for its parents vi :
∂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

that each ∂v i
∂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 multi-
layer 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,
then computing all the partial derivatives ∂L
∂u requires (at most) O(m) computations, using the above recur-
sion (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 n/2 such (xt , yt ) pairs of node, ending with L = h(xn , yn ) and with input nodes x0 and y0 .
The number of paths from x0 to L is 2n−1 . Note by mental construction how the number of paths doubles
as we increase n by 1.
4.7. Flow Graphs, Chain Rule and Backpropagation: Efficient Computation of the Gradient
21

CHAPTER
FIVE
INTRODUCTION TO MULTI-LAYER
PERCEPTRONS (FEEDFORWARD
NEURAL NETWORKS)
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 param-
eters (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.
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
P ordinary (L2)2 regression: no non-linearity (r(a) = a), squared loss L(f, (x, y)) = ||f (x) − y|| =
• for
i (fi (x) − yi ) .
23
P (L1) regression: no non-linearity (r(a) = a), absolute value loss L(f, (x, y)) = |f (x) −
• for median
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.
• multi-way probabilistic classification: softmax non-linearity (ri (a) = eai / j eaj with
P
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).
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 hL 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 L − 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
hki = tanh(bki + j Wkij hk−1,j )
In the case of a probabilistic classifier, we would then have a softmax output layer, e.g.,
• p = hL = softmax(bL + WL hL−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.
24 Chapter 5. Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)

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 )
∂aL,i = (pi − 1y=i )
and that
∂ tanh(u)
∂u = (1 − tanh(u)2 ).
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 aik and each neuron output hik is also a node.
∂L
• starting at the output node: ∂L =1
∂L ∂L ∂L
• then compute the gradient with respect to each pre-softmax sum aL,i : ∂aL,i = ∂L ∂aL,i = (pi − 1y=i )
• We can now repeat the same recipe for each layer. For k = L down to 1
∂L ∂L ∂ak,i ∂L
– obtain trivially the gradient wrt biases: ∂bk,i = ∂ak,i ∂bk,i = ∂ak,i
∂L ∂L ∂ak,i ∂L
– compute the gradient wrt weights: ∂Wk,i,j = ∂ak,i ∂Wk,i,j = ∂ak,i hk−1,j
– back-propagate the gradient into lower layer, if k > 1:

∂L P ∂L ∂ak,i P ∂L
* ∂hk−1,j = i ∂ak,i ∂hk−1,j = i ∂aki Wk,i,j
∂L ∂L ∂hk−1,j ∂L
* ∂ak−1,j = ∂hk−1,j ∂ak−1,j = ∂hk−1,j (1 − h2k−1,j )
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 garantees that there is only one minimum, which is global).
5.4. Logistic Regression 25

26 Chapter 5. Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)

CHAPTER
SIX
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 general-
ization error.
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 ∂θ j
mieux conditionnée. La dérivée second dans une certaine direction indique la courbure 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
27
θ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 )

∂C(θk+1 )
0= = 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 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 à
28 Chapter 6. Training Multi-Layer Neural Networks

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 clas-
sification, 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 clas-
sification 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
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.
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épen-
dence entre les exemples successifs. Avec certaines architectures qui captent des dépendences temporelles
6.4. Traitement des sorties désirées 29

(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 tech-
niques du second degré (surtout la technique des gradients conjugués) permettent une convergence beau-
coup 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 “activa-
tions” 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 approxi-
mativement uniformes dans l’intervalle (-1,1) (et remarquez comme les sorties des unités cachées tanh sont
aussi dans le même intervalle).
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 mau-
vaise 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 ab-
solues 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 pro-
gresse (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 dif-
ficile 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 algo-
rithme 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 valida-
tion 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
à 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.
6.9. Contrôle de la capacité effective 31

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.

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 We-
ston et al (ICML 2008) qui guident une ou plusieurs couches intermédiaires par un algo-
rithme 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éri-
mentales 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
33
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).
• 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).
34 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:
Table 8.1: Comparaison des auto-encodeurs ordinaires et débruitants

Aspect Auto-encodeurs ordinaires Auto-encodeurs débruitants
ce que ça fait trouver une représentation compacte capter la distribution jointe des entrées
critère déterministe stochastique
d’apprentissage
nombre d’unités on doit le limiter pour éviter on peut avoir autant d’unités cachées que
cachées d’apprendre l’identité nécessaire pour capter la distribution
choix de la impossible à partir du critère d’erreur on peut utiliser la moyenne de l’erreur
capacité (nombre de reconstruction, car toujours plus de reconstruction
d’unités cachées) basse avec plus d’unités
choix du nombre impossible à partir de l’erreur de on peut faire du early stopping sur
d’itérations reconstruction: utiliser l’erreur l’erreur de reconstruction moyenne
d’apprentissage classification après ajustement
supervisé
choix de la non-applicable on ne peut pas utiliser l’erreur de
quantité de reconstruction: utiliser l’erreur de
corruption des classification après ajustement supervisé
entrées
35
36 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 util-
isé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
P (x) = P 0 0
x̃ x̃ W x̃ + b x̃
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
1 Y
P (x) = ψc (xc )
Z c
où Z est le facteur de normalisation (appelée fonction de partition), et la somme 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
37
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 directe-
ment paramétrisées, souvent dans l’espace du logarithme de ψc , ce qui donne lieu à la formulation appelée
champs aléatoire de Markov:
1 − Pc Ec (xc )
P (x) = 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:
1 − Pc θc fc (xc )
P (x) = e
Z
où les seuls paramètres libres sont les θc , et où donc la log-vraisemblance complète (quand x est com-
plè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 non-
observé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 di-
rectement (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.
38 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épen-
dente de Zk−2 , Zk−3 , . . . étant donnée Zk−1 :
P (Zk |Zk−1 , Zk−2 , Zk−3 , . . .) = P (Zk |Zk−1 )
Yn
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 39

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 op-
tionnellement 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
P (x) ∝ e− 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:
− log P (x) X
= fi (x) − P (x)fi (x)
∂θi x
et le gradient moyen sur les exemples d’apprentissage xt est donc

1 X − log P (xt ) 1X X
= fi (xt ) − P (x)fi (x)
T t ∂θi T t x

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
1 X − log P (vt ) 1 XX X
= 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 41


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
Y
P (v|h) = P (vi |h)
i
43
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
X
P (vi = 1|h) = sigmoid(ci + 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−F E(v) X e
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

0
X X
F E(v) = −b0 v − log ehi (ci +v W.i )
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
0
X
F E(v) = −b0 v − log(1 + eci +v W.i )
i
X
0
F E(v) = −b v − softplus(ci + 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.
44 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 ana-
lytiquement (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-
(1)
haut, avec ĥ(1) dénote le vecteur des probabilités P (hi = 1|v1 ) et de la même manière
:math:‘hat{h}^{(2)}_i=P(h^{(2)}_i=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.
45
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 Diver-
gence, 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.
46 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
1 `
P (x, h , . . . , h ) = P (h |h ) P (h`−1 , h` )
k k+1
k=0
où l’on dénote x = h0 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
47
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 contin-
uer 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
X
log P (x) ≥ Q(h|x) (log P (h) + log P (x|h))
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).
48 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). 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.
12.3. Inférence approximative dans les DBNs 49

Null

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Null

Transféré par

Droits d'auteur :

Formats disponibles

Notes de cours IFT6266 H10

Université de Montréal, DIRO

April 02, 2010

1 IFT6266: Plan de chaque cours 1

2 Very Brief Introduction to Machine Learning for AI 9

3 Introduction to Deep Learning Algorithms 13

4 Introduction to Gradient-Based Learning 17

5 Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks) 23

6 Training Multi-Layer Neural Networks 27

7 Le défi d’entraîner des réseaux de neurones profonds 33

8 Auto-encodeurs débruitants vs auto-encodeurs ordinaires 35

9 Modèles probabilistes pour les architectures profondes 37

11 Entraînement des RBMs 45

12 RBMs empilés et DBNs 47

IFT6266: PLAN DE CHAQUE COURS

Date Sujets À lire en priorité

• Révision en vue de l’examen final

• RBMs empilés et DBNs

2 présentations d’articles de AISTATS 2010:

• Intro aux RBMs empilés et DBNs

• Tutorial sur les RBMs en Theano

• Champs markoviens, machine de Boltzmann et RBMs. La Machine de Boltzmann Restreinte. Section

• Intro aux Modèles probabilistes pour les architectures profondes.

• Résumé des Auto-encodeurs débruitants vs auto-encodeurs ordinaires

• Auto-encodeurs débruitants empilés

• Auto-encodeurs et auto-encodeurs débruitants

4 Chapter 1. IFT6266: Plan de chaque cours

1.17 1er Février

• Suite de l’entraînement des réseaux de neurones:

• Introduction to Multi-Layer Perceptrons (Feedforward Neural Networks)

• Introduction to Gradient-Based Learning

6 Chapter 1. IFT6266: Plan de chaque cours

• Introduction to Deep Learning Algorithms

• Introduction au cours, objectifs du cours, modalités d’évaluation (plan de cours)

8 Chapter 1. IFT6266: Plan de chaque cours

VERY BRIEF INTRODUCTION TO

The topics summarized here are covered in these slides.

2.2 Artificial Intelligence

2.3 Machine Learning

• Simon Haykin, “Neural Networks: a Comprehensive Foundation”, 2009 (3rd edition)

2.4 Formalization of Learning

2.5 Supervised Learning

L(f, (X, Y )) = ||f (X) − Y ||2

L(f, (X, Y )) = − log fY (X)

where we have the constraints

2.6 Unsupervised Learning

10 Chapter 2. Very Brief Introduction to Machine Learning for AI

2.7 Local Generalization

2.8 Distributed versus Local Representation and Non-Local General-

2.7. Local Generalization 11

12 Chapter 2. Very Brief Introduction to Machine Learning for AI

INTRODUCTION TO DEEP LEARNING

See the following article for a recent survey of deep learning:

3.2 Motivations for Deep Architectures

• Cognitive processes seem deep

3.3 Insufficient depth can hurt

3.4 The brain has a deep architecture

3.5 Cognitive processes seem deep

• Humans organize their ideas and concepts hierarchically.

14 Chapter 3. Introduction to Deep Learning Algorithms

3.6 Breakthrough in Learning Deep Architectures

3.6. Breakthrough in Learning Deep Architectures 15

16 Chapter 3. Introduction to Deep Learning Algorithms