Introduction au Deep Learning (notes

de cours)

Romain Tavenard

11 août 2025
 TABLE DES MATIÈRES

1 Introduction 3
1.1 Un premier modè le : le perceptron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Ré capitulatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2 Perceptrons multicouches 9
2.1 Empiler des couches pour une meilleure expressivité . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Dé cider de l’architecture d’un MLP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Fonctions d’activation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4 Dé clarer un MLP en keras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3 Fonctions de coût 17
3.1 Erreur quadratique moyenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Perte logistique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4 Optimisation 19
4.1 Descente de gradient stochastique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.2 Une note sur Adam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.3 La malé diction de la profondeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.4 Coder tout cela en keras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.5 Pré traitement des donné es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

5 Régularisation 27
5.1 Early stopping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.2 Pé nalisation de la perte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.3 DropOut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

6 Réseaux neuronaux convolutifs 33

6.1 Ré seaux de neurones convolutifs pour les sé ries temporelles . . . . . . . . . . . . . . . . . . . . . . . 33
6.2 Ré seaux de neurones convolutifs pour les images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

7 Réseaux neuronaux récurrents 41

7.1 Ré seaux ré currents standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
7.2 Long Short Term Memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.3 Gated Recurrent Unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

i
8 Mécanisme d’attention 47
8.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
8.2 Principe gé né ral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
8.3 Mé taphore : Queries, Keys, Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
8.4 Formulation mathé matique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
8.5 Auto-attention (ou self-attention) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
8.6 Multi-head attention . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
8.7 Sché ma gé né ral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
8.8 Ré sumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

9 Réseaux neuronaux génératifs 51

9.1 Auto-encodeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
9.2 Variational Auto-Encoders (VAE) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
9.3 Generative Adversarial Networks (GAN) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
9.4 Modè les de diffusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
9.5 Conditional Flow Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
9.6 Ré sumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Bibliographie 55

ii
 Introduction au Deep Learning (notes de cours)

par Romain Tavenard

Ce document sert de notes de cours pour un cours dispensé à l’Université de Rennes 2 (France) et à l’EDHEC Lille
(France).
Le cours traite des bases des ré seaux de neurones pour la classification et la ré gression sur des donné es tabulaires (y
compris les algorithmes d’optimisation pour les perceptrons multicouches), les ré seaux de neurones convolutifs pour la
classification d’images (y compris les notions d’apprentissage par transfert) et la classification / pré vision de sé quences.
Les sé ances de travaux pratiques de ce cours utiliseront keras, tout comme ces notes de cours.
NB : ces notes ont été traduites vers le français de manière semi-automatique, n’hésitez pas à vous référer à la version
anglaise en cas de doute.

TABLE DES MATIÈRES 1

Introduction au Deep Learning (notes de cours)

2 TABLE DES MATIÈRES

 CHAPITRE 1

INTRODUCTION

Dans ce chapitre d’introduction, nous allons pré senter un premier ré seau neuronal appelé le Perceptron. Ce modè le est un
ré seau neuronal constitué d’un seul neurone, et nous l’utiliserons ici pour introduire des concepts-clé s que nous dé taillerons
plus tard dans le cours.

1.1 Un premier modèle : le perceptron

Dans la terminologie des ré seaux de neurones, un neurone est une fonction paramé tré e qui prend un vecteur x en entré e
et sort une valeur unique 𝑎 comme suit :

𝑎 = 𝜑(wx
⏟ + 𝑏),
𝑜

où les paramè tres du neurone sont ses poids stocké s dans w. et un terme de biais 𝑏, et 𝜑 est une fonction d’activation qui
est choisie a priori (nous y reviendrons plus en dé tail plus tard dans le cours) :

𝑥0
𝑤0

𝑥1 𝑤
1

𝑤2 𝜑
𝑥2 𝑜 𝑎
𝑤3
𝑥3
𝑏

+1

Un modè le constitué d’un seul neurone est appelé perceptron.

3
Introduction au Deep Learning (notes de cours)

1.2 Optimisation

Les modè les pré senté s dans ce document ont pour but de ré soudre des problè mes de pré diction dans lesquels l’objectif est
de trouver des valeurs de paramè tres « suffisamment bonnes » pour le modè le en jeu compte tenu de donné es observé es.
Le problè me de la recherche de telles valeurs de paramè tres est appelé optimisation. L’apprentissage profond (ou deep
learning) fait un usage intensif d’une famille spé cifique de straté gies d’optimisation appelé e descente gradiente.

1.2.1 Descente de gradient

Pour se faire une idé e de la descente de gradient, supposons que l’on nous donne le jeu de donné es suivant sur les prix de
l’immobilier :

import pandas as pd

boston = pd.read_csv("../data/boston.csv")[["RM", "PRICE"]]

boston

RM PRICE
0 6.575 24.0
1 6.421 21.6
2 7.185 34.7
3 6.998 33.4
4 7.147 36.2
.. ... ...
501 6.593 22.4
502 6.120 20.6
503 6.976 23.9
504 6.794 22.0
505 6.030 11.9

[506 rows x 2 columns]

Dans notre cas, nous essaierons (pour commencer) de pré dire la valeur cible "PRICE" de ce jeu de donné es, qui est la
valeur mé diane des maisons occupé es par leur proprié taire en milliers de dollars en fonction du nombre moyen de piè ces
par logement "RM" :

sns.scatterplot(data=boston, x="RM", y="PRICE");

4 Chapitre 1. Introduction
 Introduction au Deep Learning (notes de cours)

Une courte note sur ce modèle

Dans la terminologie du Perceptron, ce modè le :

— n’a pas de fonction d’activation (i.e. 𝜑 est la fonction d’identité )
— n’a pas de biais (i.e. 𝑏 est fixé à 0, il n’est pas appris)

Supposons que nous ayons une approche naïve dans laquelle notre modè le de pré diction est liné aire sans biais, c’est-à -dire
que pour une entré e donné e 𝑥𝑖 la sortie pré dite est calculé e comme suit :

𝑦𝑖̂ = 𝑤𝑥𝑖

où 𝑤 est le seul paramè tre de notre modè le.

Supposons en outre que la quantité que nous cherchons à minimiser (notre objectif, é galement appelé fonction de perte)
est :
2
ℒ(𝑤) = ∑ (𝑦𝑖̂ − 𝑦𝑖 )
𝑖

où 𝑦𝑖 est la valeur cible associé e au 𝑖-è me é chantillon de jeu de donné es.
Examinons cette quantité en fonction de 𝑤 :

import numpy as np

def loss(w, x, y):

w = np.array(w)
return np.sum(
(w[:, None] * x.to_numpy()[None, :] - y.to_numpy()[None, :]) ** 2,
axis=1
)

w = np.linspace(-2, 10, num=100)

x = boston["RM"]
y = boston["PRICE"]
plt.plot(w, loss(w, x, y), "r-");

1.2. Optimisation 5
Introduction au Deep Learning (notes de cours)

Ici, il semble qu’une valeur de 𝑤 autour de 4 devrait ê tre un bon choix. Cette mé thode (gé né rer de nombreuses valeurs pour
le paramè tre et calculer la perte pour chaque valeur) ne peut pas s’adapter aux modè les qui ont beaucoup de paramè tres,
donc nous allons donc essayer autre chose.
Supposons que nous ayons accè s, à chaque fois que nous choisissons une valeur candidate pour 𝑤, à la fois à la perte
ℒ et aux informations sur la façon dont ℒ varie, localement. Nous pourrions, dans ce cas, calculer une nouvelle valeur
candidate pour 𝑤 en nous dé plaçant à partir de la valeur candidate pré cé dente dans la direction de la descente la plus raide.
C’est l’idé e de base de l’algorithme de descente du gradient qui, à partir d’un candidat initial 𝑤0 , calcule ité rativement de
nouveaux candidats comme :
𝜕ℒ
𝑤𝑡+1 = 𝑤𝑡 − 𝜌 ∣
𝜕𝑤 𝑤=𝑤𝑡

où 𝜌 est un hyper-paramè tre (appelé taux d’apprentissage) qui contrô le la taille des pas à effectuer, et 𝜕ℒ
𝜕𝑤 ∣𝑤=𝑤𝑡 est le
gradient de ℒ par rapport à 𝑤, é valué en 𝑤 = 𝑤𝑡 . Comme vous pouvez le voir, la direction de la descente la plus raide
est l’opposé de la direction indiqué e par le gradient (et cela vaut aussi pour les paramè tres vectoriels).
Ce processus est ré pé té jusqu’à la convergence, comme l’illustre la figure suivante :

rho = 1e-5

def grad_loss(w_t, x, y):

return np.sum(
2 * (w_t * x - y) * x
)

ww = np.linspace(-2, 10, num=100)

plt.plot(ww, loss(ww, x, y), "r-", alpha=.5);

w = [0.]
for t in range(10):
w_update = w[t] - rho * grad_loss(w[t], x, y)
w.append(w_update)

plt.plot(w, loss(w, x, y), "ko-")

plt.text(x=w[0]+.1, y=loss([w[0]], x, y), s="$w_{0}$")
plt.text(x=w[10]+.1, y=loss([w[10]], x, y), s="$w_{10}$");

6 Chapitre 1. Introduction
 Introduction au Deep Learning (notes de cours)

Qu’obtiendrions-nous si nous utilisions un taux d’apprentissage plus faible ?

rho = 1e-6

ww = np.linspace(-2, 10, num=100)

plt.plot(ww, loss(ww, x, y), "r-", alpha=.5);

w = [0.]
for t in range(10):
w_update = w[t] - rho * grad_loss(w[t], x, y)
w.append(w_update)

plt.plot(w, loss(w, x, y), "ko-")

plt.text(x=w[0]+.1, y=loss([w[0]], x, y), s="$w_{0}$")
plt.text(x=w[10]+.1, y=loss([w[10]], x, y), s="$w_{10}$");

Cela prendrait certainement plus de temps pour converger. Mais attention, un taux d’apprentissage plus é levé n’est pas
toujours une bonne idé e :

1.2. Optimisation 7
Introduction au Deep Learning (notes de cours)

rho = 5e-5

ww = np.linspace(-2, 10, num=100)

plt.plot(ww, loss(ww, x, y), "r-", alpha=.5);

w = [0.]
for t in range(10):
w_update = w[t] - rho * grad_loss(w[t], x, y)
w.append(w_update)

plt.plot(w, loss(w, x, y), "ko-")

plt.text(x=w[0]-1., y=loss([w[0]], x, y), s="$w_{0}$")
plt.text(x=w[10]-1., y=loss([w[10]], x, y), s="$w_{10}$");

Vous voyez comment nous divergeons lentement parce que nos pas sont trop grands ?

1.3 Récapitulatif

Dans cette section, nous avons introduit :

— un modè le trè s simple, appelé le Perceptron : ce sera une brique de base pour les modè les plus avancé s que nous
dé taillerons plus tard dans le cours, tels que :
— le Perceptron multi-couches
— les architectures convolutionnelles
— les architectures récurrentes
— les architectures basées attention
— le fait qu’une tâ che s’accompagne d’une fonction de perte à minimiser (ici, nous avons utilisé l’erreur quadratique
moyenne pour notre tâ che de ré gression), qui sera discuté e dans un chapitre dédié ;
— le concept de descente de gradient pour optimiser la perte choisie sur le paramè tre unique d’un modè le, et ceci
sera é tendu dans notre chapitre sur l’optimisation.

8 Chapitre 1. Introduction
 CHAPITRE 2

PERCEPTRONS MULTICOUCHES

Dans le chapitre pré cé dent, nous avons vu un modè le trè s simple appelé le perceptron. Dans ce modè le, la sortie pré dite
𝑦 ̂ est calculé e comme une combinaison liné aire des caracté ristiques d’entré e plus un biais :
𝑑
𝑦 ̂ = ∑ 𝑥𝑗 𝑤𝑗 + 𝑏
𝑗=1

En d’autres termes, nous optimisions parmi la famille des modè les liné aires, qui est une famille assez restreinte.

2.1 Empiler des couches pour une meilleure expressivité

Afin de couvrir un plus large é ventail de modè les, on peut empiler des neurones organisé s en couches pour former un
modè le plus complexe, comme le modè le ci-dessous, qui est appelé modè le à une couche caché e, car une couche supplé -
mentaire de neurones est introduite entre les entré es et la sortie :
Couche d'entré e Couche caché e Couche de sortie
x h(1) ŷ

w(0) w(1)

9
Introduction au Deep Learning (notes de cours)

La question que l’on peut se poser maintenant est de savoir si cette couche caché e supplé mentaire permet effectivement
de couvrir une plus grande famille de modè les. C’est à cela que sert le thé orè me d’approximation universelle ci-dessous.

® Théorème d’approximation universelle

Le thé orè me d’approximation universelle stipule que toute fonction continue dé finie sur un ensemble compact peut
ê tre approché e d’aussi prè s que l’on veut par un ré seau neuronal à une couche caché e avec activation sigmoïde.

En d’autres termes, en utilisant une couche caché e pour mettre en correspondance les entré es et les sorties, on peut
maintenant approximer n’importe quelle fonction continue, ce qui est une proprié té trè s inté ressante. Notez cependant
que le nombre de neurones caché s né cessaire pour obtenir une qualité d’approximation donné e n’est pas discuté ici. De
plus, il n’est pas suffisant qu’une telle bonne approximation existe, une autre question importante est de savoir si les
algorithmes d’optimisation que nous utiliserons convergeront in fine vers cette solution ou non, ce qui n’est pas garanti,
comme discuté plus en dé tail dans le chapitre dédié.
En pratique, nous observons empiriquement que pour atteindre une qualité d’approximation donné e, il est plus efficace
(en termes de nombre de paramè tres requis) d’empiler plusieurs couches caché es plutô t que de s’appuyer sur une seule :
Premiè re Seconde Couche de sortie
Couche d'entré e
couche caché e couche caché e ŷ
x
h(1) h(2)

w(0) w(1) w(2)

La repré sentation graphique ci-dessus correspond au modè le suivant :

(2) (2)
𝑦 ̂ = 𝜑out (∑ 𝑤𝑖 ℎ𝑖 + 𝑏(2) ) (2.1)
𝑖

(2) (1) (1) (1)

∀𝑖, ℎ𝑖 = 𝜑 (∑ 𝑤𝑖𝑗 ℎ𝑗 + 𝑏𝑖 ) (2.2)
𝑗

(1) (0) (0)

∀𝑖, ℎ𝑖 = 𝜑 (∑ 𝑤𝑖𝑗 𝑥𝑗 + 𝑏𝑖 ) (2.3)
𝑗

(𝑙)
Pour ê tre pré cis, les termes de biais 𝑏𝑖 ne sont pas repré senté s dans la repré sentation graphique ci-dessus.
De tels modè les avec une ou plusieurs couches caché es sont appelé s Perceptrons multicouches (ou Multi-Layer Percep-
trons, MLP).

10 Chapitre 2. Perceptrons multicouches

 Introduction au Deep Learning (notes de cours)

2.2 Décider de l’architecture d’un MLP

Lors de la conception d’un modè le de perceptron multicouche destiné à ê tre utilisé pour un problè me spé cifique, certaines
quantité s sont fixé es par le problè me en question et d’autres sont des hyper-paramè tres du modè le.
Prenons l’exemple du cé lè bre jeu de donné es de classification d’iris :

import pandas as pd

iris = pd.read_csv("../data/iris.csv", index_col=0)

iris

sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) \
0 5.1 3.5 1.4 0.2
1 4.9 3.0 1.4 0.2
2 4.7 3.2 1.3 0.2
3 4.6 3.1 1.5 0.2
4 5.0 3.6 1.4 0.2
.. ... ... ... ...
145 6.7 3.0 5.2 2.3
146 6.3 2.5 5.0 1.9
147 6.5 3.0 5.2 2.0
148 6.2 3.4 5.4 2.3
149 5.9 3.0 5.1 1.8

target
0 0
1 0
2 0
3 0
4 0
.. ...
145 2
146 2
147 2
148 2
149 2

[150 rows x 5 columns]

L’objectif ici est d’apprendre à dé duire l’attribut « cible » (3 classes diffé rentes possibles) à partir des informations conte-
nues dans les 4 autres attributs.
La structure de ce jeu de donné es dicte :
— le nombre de neurones dans la couche d’entré e, qui est é gal au nombre d’attributs descriptifs dans notre jeu de
donné es (ici, 4), et
— le nombre de neurones dans la couche de sortie, qui est ici é gal à 3, puisque le modè le est censé produire une
probabilité par classe cible.
De maniè re plus gé né rale, pour la couche de sortie, on peut ê tre confronté à plusieurs situations :
— lorsqu’il s’agit de ré gression, le nombre de neurones de la couche de sortie est é gal au nombre de caracté ristiques
à pré dire par le modè le,
— quand il s’agit de classification
— Dans le cas d’une classification binaire, le modè le aura un seul neurone de sortie qui indiquera la probabilité
de la classe positive,

2.2. Décider de l’architecture d’un MLP 11

Introduction au Deep Learning (notes de cours)

— dans le cas d’une classification multi-classes, le modè le aura autant de neurones de sortie que le nombre de
classes du problè me.
Une fois que ces nombres de neurones d’entré e / sortie sont fixé s, le nombre de neurones caché s ainsi que le nombre de
neurones par couche caché e restent des hyper-paramè tres du modè le.

2.3 Fonctions d’activation

Un autre hyper-paramè tre important des ré seaux neuronaux est le choix de la fonction d’activation 𝜑.
Il est important de noter que si nous utilisons la fonction identité comme fonction d’activation, quelle que soit la profondeur
de notre MLP, nous ne couvrirons plus que la famille des modè les liné aires. En pratique, nous utiliserons donc des
fonctions d’activation qui ont un certain ré gime liné aire mais qui ne se comportent pas comme une fonction liné aire sur
toute la gamme des valeurs d’entré e.
Historiquement, les fonctions d’activation suivantes ont é té proposé es :
2
tanh(𝑥) = −1
1 + 𝑒−2𝑥
1
sigmoid(𝑥) =
1 + 𝑒−𝑥
𝑥 si 𝑥 > 0
ReLU(𝑥) = {
0 sinon

En pratique, la fonction ReLU (et certaines de ses variantes) est la plus utilisé e de nos jours, pour des raisons qui seront
discuté es plus en dé tail dans notre chapitre consacré à l’optimisation.

2.3.1 Le cas particulier de la couche de sortie

Vous avez peut-ê tre remarqué que dans la formulation du MLP fournie par l’é quation (1), la couche de sortie possè de sa
propre fonction d’activation, noté e 𝜑out . Cela s’explique par le fait que le choix de la fonction d’activation pour la couche
de sortie d’un ré seau neuronal est spé cifique au problè me à ré soudre.
En effet, vous avez pu constater que les fonctions d’activation abordé es dans la section pré cé dente ne partagent pas la
mê me plage de valeurs de sortie. Il est donc primordial de choisir une fonction d’activation adé quate pour la couche de
sortie, de sorte que notre modè le produise des valeurs cohé rentes avec les quantité s qu’il est censé pré dire.
Si, par exemple, notre modè le est censé ê tre utilisé dans l’ensemble de donné es sur les logements de Boston dont nous
avons parlé dans le chapitre précédent, l’objectif est de pré dire les prix des logements, qui sont censé s ê tre des quantité s non

12 Chapitre 2. Perceptrons multicouches

 Introduction au Deep Learning (notes de cours)

né gatives. Il serait donc judicieux d’utiliser ReLU (qui peut produire toute valeur positive) comme fonction d’activation
pour la couche de sortie dans ce cas.
Comme indiqué pré cé demment, dans le cas de la classification binaire, le modè le aura un seul neurone de sortie et ce
neurone produira la probabilité associé e à la classe positive. Cette quantité devra se situer dans l’intervalle [0, 1], et la
fonction d’activation sigmoïde est alors le choix par dé faut dans ce cas.
Enfin, lorsque la classification multi-classes est en jeu, nous avons un neurone par classe de sortie et chaque neurone est
censé fournir la probabilité pour une classe donné e. Dans ce contexte, les valeurs de sortie doivent ê tre comprises entre
0 et 1, et leur somme doit ê tre é gale à 1. À cette fin, nous utilisons la fonction d’activation softmax dé finie comme suit :
𝑒𝑜𝑖
∀𝑖, softmax(𝑜𝑖 ) =
∑𝑗 𝑒𝑜𝑗

où , pour tous les 𝑖, les 𝑜𝑖 sont les valeurs des neurones de sortie avant application de la fonction d’activation.

2.4 Déclarer un MLP en keras

Pour dé finir un modè le MLP dans keras, il suffit d’empiler des couches. A titre d’exemple, si l’on veut coder un modè le
composé de :
— une couche d’entré e avec 10 neurones,
— d’une couche caché e de 20 neurones avec activation ReLU,
— une couche de sortie composé e de 3 neurones avec activation softmax,
le code sera le suivant :

import keras
from keras.layers import Dense, InputLayer
from keras.models import Sequential

model = Sequential([
InputLayer(input_shape=(10, )),
Dense(units=20, activation="relu"),
Dense(units=3, activation="softmax")
])

model.summary()

Model: "sequential"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type) ┃ Output Shape ┃ Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ dense (Dense) │ (None, 20) │ 220 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_1 (Dense) │ (None, 3) │ 63 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

Total params: 283 (1.11 KB)

Trainable params: 283 (1.11 KB)

2.4. Déclarer un MLP en keras 13

Introduction au Deep Learning (notes de cours)

Non-trainable params: 0 (0.00 B)

Notez que model.summary() fournit un aperçu inté ressant d’un modè le dé fini et de ses paramè tres.

® Exercice #1

En vous basant sur ce que nous avons vu dans ce chapitre, pouvez-vous expliquer le nombre de paramè tres retourné s
par model.summary() ci-dessus ?

® Solution

Notre couche d’entré e est composé e de 10 neurones, et notre premiè re couche est entiè rement connecté e, donc
chacun de ces neurones est connecté à un neurone de la couche caché e par un paramè tre, ce qui fait dé jà 10×20 =
200 paramè tres. De plus, chacun des neurones de la couche caché e possè de son propre paramè tre de biais, ce qui
fait 20 paramè tres supplé mentaires. Nous avons donc 220 paramè tres, tels que sortis par model.summary()
pour la couche "dense (Dense)".
De la mê me maniè re, pour la connexion des neurones de la couche caché e à ceux de la couche de sortie, le nombre
total de paramè tres est de 20 × 3 = 60 pour les poids plus 3 paramè tres supplé mentaires pour les biais.
Au total, nous avons 220 + 63 = 283 paramè tres dans ce modè le.

® Exercice #2

Dé clarez, en keras, un MLP avec une couche caché e composé e de 100 neurones et une activation ReLU pour le
jeu de donné es Iris pré senté ci-dessus.

® Solution

model = Sequential([
InputLayer(input_shape=(4, )),
Dense(units=100, activation="relu"),
Dense(units=3, activation="softmax")
])

® Exercice #3

Mê me question pour le jeu de donné es sur le logement à Boston pré senté ci-dessous (le but ici est de pré dire l’attribut
PRICE en fonction des autres).

® Solution

model = Sequential([
InputLayer(input_shape=(6, )),
Dense(units=100, activation="relu"),
Dense(units=1, activation="relu")
])

14 Chapitre 2. Perceptrons multicouches

 Introduction au Deep Learning (notes de cours)

RM CRIM INDUS NOX AGE TAX PRICE

0 6.575 0.00632 2.31 0.538 65.2 296.0 24.0
1 6.421 0.02731 7.07 0.469 78.9 242.0 21.6
2 7.185 0.02729 7.07 0.469 61.1 242.0 34.7
3 6.998 0.03237 2.18 0.458 45.8 222.0 33.4
4 7.147 0.06905 2.18 0.458 54.2 222.0 36.2
.. ... ... ... ... ... ... ...
501 6.593 0.06263 11.93 0.573 69.1 273.0 22.4
502 6.120 0.04527 11.93 0.573 76.7 273.0 20.6
503 6.976 0.06076 11.93 0.573 91.0 273.0 23.9
504 6.794 0.10959 11.93 0.573 89.3 273.0 22.0
505 6.030 0.04741 11.93 0.573 80.8 273.0 11.9

[506 rows x 7 columns]

2.4. Déclarer un MLP en keras 15

Introduction au Deep Learning (notes de cours)

16 Chapitre 2. Perceptrons multicouches

 CHAPITRE 3

FONCTIONS DE COÛT

Nous avons maintenant pré senté une premiè re famille de modè les, qui est la famille MLP. Afin d’entraîner ces modè les
(i.e. d’ajuster leurs paramè tres pour qu’ils s’adaptent aux donné es), nous devons dé finir une fonction de coû t (aussi appelé e
fonction de perte, ou loss function) à optimiser. Une fois cette fonction choisie, l’optimisation consistera à ré gler les
paramè tres du modè le de maniè re à la minimiser.
Dans cette section, nous pré senterons deux fonctions de pertes standard, à savoir l’erreur quadratique moyenne (princi-
palement utilisé e pour la ré gression) et la fonction de perte logistique (utilisé e en classification).
Dans ce qui suit, nous supposons connu un ensemble de donné es 𝒟 composé de 𝑛 é chantillons annoté s (𝑥𝑖 , 𝑦𝑖 ), et nous
dé signons la sortie du modè le :

∀𝑖, 𝑦𝑖̂ = 𝑚𝜃 (𝑥𝑖 )

où 𝑚𝜃 est notre modè le et 𝜃 est l’ensemble de tous ses paramè tres (poids et biais).

3.1 Erreur quadratique moyenne

L’erreur quadratique moyenne (ou Mean Squared Error, MSE) est la fonction de perte la plus couramment utilisé e dans
les contextes de ré gression. Elle est dé finie comme suit
1
ℒ(𝒟; 𝑚𝜃 ) = ∑ ‖𝑦𝑖̂ − 𝑦𝑖 ‖2
𝑛 𝑖
1
= ∑ ‖𝑚𝜃 (𝑥𝑖 ) − 𝑦𝑖 ‖2
𝑛 𝑖

Sa forme quadratique tend à pé naliser fortement les erreurs importantes :

17
Introduction au Deep Learning (notes de cours)

3.2 Perte logistique

La perte logistique est la fonction de perte la plus largement utilisé e pour entraîner des ré seaux neuronaux dans des
contextes de classification. Elle est dé finie comme suit
1
ℒ(𝒟; 𝑚𝜃 ) = ∑ − log 𝑝(𝑦𝑖̂ = 𝑦𝑖 ; 𝑚𝜃 )
𝑛 𝑖

où 𝑝(𝑦𝑖̂ = 𝑦𝑖 ; 𝑚𝜃 ) est la probabilité pré dite par le modè le 𝑚𝜃 pour la classe correcte 𝑦𝑖 .
Sa formulation tend à favoriser les cas où le modè le pré dit la classe correcte avec une probabilité proche de 1, comme on
peut s’y attendre :

18 Chapitre 3. Fonctions de coût

 CHAPITRE 4

OPTIMISATION

Dans ce chapitre, nous pré senterons des variantes de la straté gie d’optimisation de descente de gradient et montrerons
comment elles peuvent ê tre utilisé es pour optimiser les paramè tres des ré seaux de neurones.
Commençons par l’algorithme de base de la descente de gradient et ses limites.

® Algorithm 1 (Descente de Gradient)

Entrée: Un jeu de donné es 𝒟 = (𝑋, 𝑦)

1. Initialiser les paramè tres 𝜃 du modè le
2. for 𝑒 = 1..𝐸
1. for (𝑥𝑖 , 𝑦𝑖 ) ∈ 𝒟
1. Calculer la pré diction 𝑦𝑖̂ = 𝑚𝜃 (𝑥𝑖 )
2. Calculer le gradient individuel ∇𝜃 ℒ𝑖
2. Calculer le gradient total ∇𝜃 ℒ = 𝑛1 ∑𝑖 ∇𝜃 ℒ𝑖
3. Mettre à jour les paramè tres 𝜃 à partir de ∇𝜃 ℒ

La rè gle de mise à jour typique pour les paramè tres 𝜃 à l’ité ration 𝑡 est

𝜃(𝑡+1) ← 𝜃(𝑡) − 𝜌∇𝜃 ℒ

où 𝜌 est un hyper-paramè tre important de la mé thode, appelé le taux d’apprentissage (ou learning rate). La descente de
gradient consiste à jour ité rativement 𝜃 dans la direction de la plus forte diminution de la perte ℒ.
Comme on peut le voir dans l’algorithme pré cé dent, lors d’un descente de gradient, les paramè tres du modè le sont mis
à jour une fois par epoch, ce qui signifie qu’un passage complet sur l’ensemble des donné es est né cessaire avant la mise
à jour. Lorsque l’on traite de grands jeux de donné es, cela constitue une forte limitation, ce qui motive l’utilisation de
variantes stochastiques.

19
Introduction au Deep Learning (notes de cours)

4.1 Descente de gradient stochastique

L’idé e derriè re l’algorithme de descente de gradient stochastique (ou Stochastic Gradient Descent, SGD) est d’obtenir des
estimations bon marché (au sens de la quantité de calculs né cessaires) pour la quantité
1
∇𝜃 ℒ(𝒟; 𝑚𝜃 ) = ∑ ∇ ℒ(𝑥𝑖 , 𝑦𝑖 ; 𝑚𝜃 )
𝑛 (𝑥 ,𝑦 )∈𝒟 𝜃
𝑖 𝑖

où 𝒟 est l’ensemble d’apprentissage. Pour ce faire, on tire des sous-ensembles de donné es, appelé s minibatchs, et
1
∇𝜃 ℒ(ℬ; 𝑚𝜃 ) = ∑ ∇ ℒ(𝑥𝑖 , 𝑦𝑖 ; 𝑚𝜃 )
𝑏 (𝑥 ,𝑦 )∈ℬ 𝜃
𝑖 𝑖

est utilisé comme estimateur de ∇𝜃 ℒ(𝒟; 𝑚𝜃 ). Il en ré sulte l’algorithme suivant dans lequel les mises à jour des paramè tres
se produisent aprè s chaque minibatch, c’est-à -dire plusieurs fois par epoch.

® Algorithm 2 (Descente de gradient stochastique)

Input: A dataset 𝒟 = (𝑋, 𝑦)

1. Initialiser les paramè tres 𝜃 du modè le
2. for 𝑒 = 1..𝐸
1. for 𝑡 = 1..𝑛minibatches
1. Tirer un é chantillon alé atoire de taillle 𝑏 dans 𝒟 que l’on appelle minibatch
2. for (𝑥𝑖 , 𝑦𝑖 ) ∈ ℬ
1. Calculer la pré diction 𝑦𝑖̂ = 𝑚𝜃 (𝑥𝑖 )
2. Calculer le gradient individuel ∇𝜃 ℒ𝑖
1
3. Calculer le gradient sommé sur le minibatch ∇𝜃 ℒℬ = 𝑏 ∑𝑖 ∇𝜃 ℒ𝑖
4. Mettre à jour les paramè tres 𝜃 à partir de ∇𝜃 ℒℬ

Par consé quent, lors de l’utilisation de SGD, les mises à jour des paramè tres sont plus fré quentes, mais elles sont « brui-
té es » puisqu’elles sont basé es sur une estimation du gradient par minibatch au lieu de s’appuyer sur le vrai gradient,
comme illustré ci-dessous :

20 Chapitre 4. Optimisation
 Introduction au Deep Learning (notes de cours)

Outre le fait qu’elle implique des mises à jour plus fré quentes des paramè tres, la SGD pré sente un avantage supplé mentaire
en termes d’optimisation, qui est essentiel pour les ré seaux de neurones. En effet, comme on peut le voir ci-dessous,
contrairement à ce que nous avions dans le cas du Perceptron, la perte MSE (et il en va de mê me pour la perte logistique)
n’est plus convexe en les paramè tres du modè le dè s que celui-ci possè de au moins une couche caché e :

La descente de gradient est connue pour souffrir d’optima locaux, et de tels fonctions de pertes constituent un problè me
sé rieux pour la descente de gradient. D’un autre cô té , la descente de gradient stochastique est susceptible de bé né ficier
d’estimations de gradient bruité es pour s’é chapper des minima locaux.

4.1. Descente de gradient stochastique 21

Introduction au Deep Learning (notes de cours)

4.2 Une note sur Adam

Adam [Kingma and Ba, 2015] est une variante de la mé thode de descente de gradient stochastique. Elle diffè re dans la
rè gle de mise à jour des paramè tres.
Tout d’abord, elle utilise ce qu’on appelle le momentum, qui consiste essentiellement à s’appuyer sur les mises à jour
anté rieures du gradient pour lisser la trajectoire dans l’espace des paramè tres pendant l’optimisation. Une illustration
interactive du momentum peut ê tre trouvé e dans [Goh, 2017].
L’estimation du gradient est remplacé e par la quantité :
1
m(𝑡+1) ← [𝛽 m(𝑡) + (1 − 𝛽1 )∇𝜃 ℒ]
1 − 𝛽1𝑡 1

Lorsque 𝛽1 est é gal à zé ro, nous avons m(𝑡+1) = ∇𝜃 ℒ et pour 𝛽1 ∈]0, 1[, m(𝑡+1) l’estimation courante du gradient utilise
l’information sur les estimations passé es, stocké e dans m(𝑡) .
Une autre diffé rence importante entre SGD et la Adam consiste à utiliser un taux d’apprentissage adaptatif. En d’autres
termes, au lieu d’utiliser le mê me taux d’apprentissage 𝜌 pour tous les paramè tres du modè le, le taux d’apprentissage pour
un paramè tre donné 𝜃𝑖 est dé fini comme :
𝜌
𝜌(𝑡+1)
̂ (𝜃𝑖 ) =
√𝑠(𝑡+1) (𝜃𝑖 ) + 𝜖

où 𝜖 est une constante petite devant 1 et

1 2
𝑠(𝑡+1) (𝜃𝑖 ) = (𝑡)
𝑡 [𝛽2 𝑠 (𝜃𝑖 ) + (1 − 𝛽2 ) (∇𝜃𝑖 ℒ) ]
1 − 𝛽2

Ici aussi, le terme 𝑠 utilise le momentum. Par consé quent, le taux d’apprentissage sera ré duit pour les paramè tres qui ont
subi de grandes mises à jour dans les ité rations pré cé dentes.
Globalement, la rè gle de mise à jour d’Adam est la suivante :

𝜃(𝑡+1) ← 𝜃(𝑡) − 𝜌(𝑡+1)

̂ (𝜃)m(𝑡+1)

4.3 La malédiction de la profondeur

Considé rons le ré seau neuronal suivant :

w(0) w(1) w(2)

22 Chapitre 4. Optimisation
 Introduction au Deep Learning (notes de cours)

et rappelons que, pour une couche donné e (ℓ), la sortie de la couche est calculé e comme suit

𝑎(ℓ) = 𝜑(𝑜(ℓ) ) = 𝜑(𝑤(ℓ−1) 𝑎(ℓ−1) )

où 𝜑 est la fonction d’activation pour la couche donné e (nous ignorons les termes de biais dans cet exemple simplifié ).
Afin d’effectuer une descente de gradient (stochastique), les gradients de la perte par rapport aux paramè tres du modè le
doivent ê tre calculé s.
En utilisant la rè gle de la dé rivation en chaîne, ces gradients peuvent ê tre exprimé s comme suit :

𝜕ℒ 𝜕ℒ 𝜕𝑎(3) 𝜕𝑜(3)
=
𝜕𝑤(2) 𝜕𝑎(3) 𝜕𝑜(3) 𝜕𝑤(2)
𝜕ℒ 𝜕ℒ 𝜕𝑎(3) 𝜕𝑜(3) 𝜕𝑎(2) 𝜕𝑜(2)
=
𝜕𝑤(1) 𝜕𝑎(3) 𝜕𝑜(3) 𝜕𝑎(2) 𝜕𝑜(2) 𝜕𝑤(1)
𝜕ℒ 𝜕ℒ 𝜕𝑎(3) 𝜕𝑜(3) 𝜕𝑎(2) 𝜕𝑜(2) 𝜕𝑎(1) 𝜕𝑜(1)
(0)
=
𝜕𝑤 𝜕𝑎(3) 𝜕𝑜(3) 𝜕𝑎(2) 𝜕𝑜(2) 𝜕𝑎(1) 𝜕𝑜(1) 𝜕𝑤(0)
Il y a des idé es importantes à saisir ici.
Tout d’abord, il faut remarquer que les poids qui sont plus é loigné s de la sortie du modè le hé ritent de rè gles de gradient
composé es de plus de termes. Par consé quent, lorsque certains de ces termes deviennent de plus en plus petits, il y a un
risque plus é levé pour ces poids que leurs gradients tombent à 0. C’est ce qu’on appelle l’effet de gradient évanescent
(vanishing gradient), qui est un phé nomè ne trè s courant dans les ré seaux neuronaux profonds (c’est-à -dire les ré seaux
composé s de nombreuses couches).
𝜕𝑎(ℓ) 𝜕𝑜(ℓ)
Deuxiè mement, certains termes sont ré pé té s dans ces formules, et en gé né ral, des termes de la forme 𝜕𝑜(ℓ)
et 𝜕𝑎(ℓ−1)
sont
pré sents à plusieurs endroits. Ces termes peuvent ê tre dé veloppé s comme suit :

𝜕𝑎(ℓ)
= 𝜑′ (𝑜(ℓ) )
𝜕𝑜(ℓ)
𝜕𝑜(ℓ)
= 𝑤(ℓ−1)
𝜕𝑎(ℓ−1)
Voyons à quoi ressemblent les dé rivé es des fonctions d’activation standard :

On peut constater que la dé rivé e de ReLU possè de une plus grande plage de valeurs d’entré e pour lesquelles elle est non
nulle (typiquement toute la plage de valeurs d’entré e positives) que ses concurrentes, ce qui en fait une fonction d’activation
(ℓ)
trè s inté ressante pour les ré seaux neuronaux profonds, car nous avons vu que le terme 𝜕𝑎
𝜕𝑜(ℓ)
apparaît de maniè re ré pé té e
dans les dé rivations en chaîne.

4.3. La malédiction de la profondeur 23

Introduction au Deep Learning (notes de cours)

4.4 Coder tout cela en keras

Dans keras, les informations sur les pertes et l’optimiseur sont transmises au moment de la compilation :

import keras
from keras.layers import Dense, InputLayer
from keras.models import Sequential

model = Sequential([
InputLayer(input_shape=(10, )),
Dense(units=20, activation="relu"),
Dense(units=3, activation="softmax")
])

model.summary()

Model: "sequential"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type) ┃ Output Shape ┃ Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ dense (Dense) │ (None, 20) │ 220 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_1 (Dense) │ (None, 3) │ 63 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

Total params: 283 (1.11 KB)

Trainable params: 283 (1.11 KB)

Non-trainable params: 0 (0.00 B)

model.compile(loss="categorical_crossentropy", optimizer="adam")

En termes de pertes :
— "mse" est la perte d’erreur quadratique moyenne,
— "binary_crossentropy" est la perte logistique pour la classification binaire,
— "categorical_crossentropy" est la perte logistique pour la classification multi-classes.
Les optimiseurs dé finis dans cette section sont disponibles sous forme de "sgd" et "adam". Afin d’avoir le contrô le sur
les hyper-paramè tres des optimiseurs, on peut alternativement utiliser la syntaxe suivante :

from keras.optimizers import Adam, SGD

# Not a very good idea to tune beta_1

# and beta_2 parameters in Adam
adam_opt = Adam(learning_rate=0.001,
beta_1=0.9, beta_2=0.9)

# In order to use SGD with a custom learning rate:

# sgd_opt = SGD(learning_rate=0.001)

model.compile(loss="categorical_crossentropy", optimizer=adam_opt)

24 Chapitre 4. Optimisation
 Introduction au Deep Learning (notes de cours)

4.5 Prétraitement des données

En pratique, pour que la phase d’ajustement du modè le se dé roule correctement, il est important de mettre à l’é chelle les
donné es d’entré e. Dans l’exemple suivant, nous allons comparer deux entraînements du mê me modè le, avec une initialisa-
tion similaire et la seule diffé rence entre les deux sera de savoir si les donné es d’entré e sont centré es-ré duites ou laissé es
telles quelles.

import pandas as pd
from keras.utils import to_categorical

iris = pd.read_csv("../data/iris.csv", index_col=0)

iris = iris.sample(frac=1)
y = to_categorical(iris["target"])
X = iris.drop(columns=["target"])

from keras.layers import Dense, InputLayer

from keras.models import Sequential
from keras.utils import set_random_seed

set_random_seed(0)
model = Sequential([
InputLayer(input_shape=(4, )),
Dense(units=256, activation="relu"),
Dense(units=256, activation="relu"),
Dense(units=256, activation="relu"),
Dense(units=3, activation="softmax")
])

n_epochs = 100
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
h = model.fit(X, y, epochs=n_epochs, batch_size=30, verbose=0)

Standardisons maintenant nos donné es et comparons les performances obtenues :

X -= X.mean(axis=0)
X /= X.std(axis=0)

set_random_seed(0)
model = Sequential([
InputLayer(input_shape=(4, )),
Dense(units=256, activation="relu"),
Dense(units=256, activation="relu"),
Dense(units=256, activation="relu"),
Dense(units=3, activation="softmax")
])

n_epochs = 100
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
h_standardized = model.fit(X, y, epochs=n_epochs, batch_size=30, verbose=0)

4.5. Prétraitement des données 25

Introduction au Deep Learning (notes de cours)

26 Chapitre 4. Optimisation
 CHAPITRE 5

RÉGULARISATION

Comme nous l’avons vu dans les chapitres pré cé dents, l’une des forces des ré seaux neuronaux est qu’ils peuvent approximer
n’importe quelle fonction continue lorsqu’un nombre suffisant de paramè tres est utilisé . Lors de l’utilisation d’approxima-
teurs universels dans des contextes d’apprentissage automatique, un risque connexe important est celui du surajustement
(overfitting) aux donné es d’apprentissage. Plus formellement, é tant donné un jeu de donné es d’apprentissage 𝒟𝑡 tiré d’une
distribution inconnue 𝒟, les paramè tres du modè le sont optimisé s de maniè re à minimiser le risque empirique :
1
ℛ𝑒 (𝜃) = ∑ ℒ(𝑥𝑖 , 𝑦𝑖 ; 𝑚𝜃 )
|𝒟𝑡 | (𝑥 ,𝑦 )∈𝒟
𝑖 𝑖 𝑡

alors que le vé ritable objectif est de minimiser le « vrai » risque :

ℛ(𝜃) = 𝔼𝑥,𝑦∼𝒟 ℒ(𝑥, 𝑦; 𝑚𝜃 )

et les deux objectifs n’ont pas le mê me minimiseur.

Pour é viter cet é cueil, il faut utiliser des techniques de ré gularisation, telles que celles pré senté es ci-aprè s.

5.1 Early stopping

Comme illustré ci-dessous, on peut observer que l’entraînement d’un ré seau neuronal pendant un trop grand nombre
d”epochs peut conduire à un surajustement. Notez qu’ici, le risque ré el est estimé grâ ce à l’utilisation d’un ensemble de
validation qui n’est pas vu pendant l’entraînement.

iris = pd.read_csv("../data/iris.csv", index_col=0)

iris = iris.sample(frac=1)
y = to_categorical(iris["target"])
X = iris.drop(columns=["target"])
X -= X.mean(axis=0)
X /= X.std(axis=0)

27
Introduction au Deep Learning (notes de cours)

import keras
from keras.layers import Dense, InputLayer
from keras.models import Sequential
from keras.utils import set_random_seed

set_random_seed(0)
model = Sequential([
InputLayer(input_shape=(4, )),
Dense(units=256, activation="relu"),
Dense(units=256, activation="relu"),
Dense(units=256, activation="relu"),
Dense(units=3, activation="softmax")
])

n_epochs = 100
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
h = model.fit(X, y, validation_split=0.3, epochs=n_epochs, batch_size=30, verbose=0)

Ici, le meilleur modè le (en termes de capacité s de gé né ralisation) semble ê tre le modè le à l”epoch np.int64(23). En
d’autres termes, si nous avions arrê té le processus d’apprentissage aprè s l”epoch np.int64(23), nous aurions obtenu un
meilleur modè le que si nous utilisons le modè le entraîné pendant 70 epochs.
C’est toute l’idé e derriè re la straté gie d”early stopping, qui consiste à arrê ter le processus d’apprentissage dè s que la perte
de validation cesse de s’amé liorer. Cependant, comme on peut le voir dans la visualisation ci-dessus, la perte de validation
a tendance à osciller, et on attend souvent plusieurs epochs avant de supposer que la perte a peu de chances de s’amé liorer
dans le futur. Le nombre d”epochs à attendre est appelé le paramè tre de patience.
Dans keras, l’arrê t anticipé peut ê tre configuré via un callback, comme dans l’exemple suivant :

from keras.callbacks import EarlyStopping

set_random_seed(0)
(suite sur la page suivante)

28 Chapitre 5. Régularisation
 Introduction au Deep Learning (notes de cours)

(suite de la page pré cé dente)

model = Sequential([
InputLayer(input_shape=(4, )),
Dense(units=256, activation="relu"),
Dense(units=256, activation="relu"),
Dense(units=256, activation="relu"),
Dense(units=3, activation="softmax")
])

cb_es = EarlyStopping(monitor="val_loss", patience=10, restore_best_weights=True)

n_epochs = 100
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
h = model.fit(X, y,
validation_split=0.3, epochs=n_epochs, batch_size=30,
verbose=0, callbacks=[cb_es])

Et maintenant, mê me si le modè le é tait pré vu pour ê tre entraîné pendant 70 epochs, l’entraînement est arrê té dè s qu’il
atteint 10 epochs consé cutives sans amé lioration de la perte de validation, et les paramè tres du modè le sont restauré s
comme les paramè tres du modè le à l”epoch np.int64(23).

5.2 Pénalisation de la perte

Une autre façon importante d’appliquer la ré gularisation dans les ré seaux neuronaux est la pé nalisation des pertes. Un
exemple typique de cette straté gie de ré gularisation est la ré gularisation L2. Si nous dé signons par ℒ𝑟 la perte ré gularisé e
par L2, elle peut ê tre exprimé e comme suit :

ℒ𝑟 (𝒟; 𝑚𝜃 ) = ℒ(𝒟; 𝑚𝜃 ) + 𝜆 ∑ ‖𝜃(ℓ) ‖22

ℓ

où 𝜃(ℓ) est la matrice de poids de la couche ℓ.

Cette ré gularisation tend à ré duire les grandes valeurs des paramè tres pendant le processus d’apprentissage, ce qui est
connu pour aider à amé liorer la gé né ralisation.

5.2. Pénalisation de la perte 29

Introduction au Deep Learning (notes de cours)

En keras, ceci est implé menté comme :

from keras.regularizers import L2

λ = 0.01

set_random_seed(0)
model = Sequential([
InputLayer(input_shape=(4, )),
Dense(units=256, activation="relu", kernel_regularizer=L2(λ)),
Dense(units=256, activation="relu", kernel_regularizer=L2(λ)),
Dense(units=256, activation="relu", kernel_regularizer=L2(λ)),
Dense(units=3, activation="softmax")
])

n_epochs = 100
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
h = model.fit(X, y, validation_split=0.3, epochs=n_epochs, batch_size=30, verbose=0)

5.3 DropOut

Dans cette section, nous pré sentons la straté gie DropOut, qui a é té introduite dans [Srivastava et al., 2014]. L’idé e derriè re
le DropOut est d’é teindre certains neurones pendant l’apprentissage. Les neurones dé sactivé s changent à chaque minibatch
de sorte que, globalement, tous les neurones sont entraîné s pendant tout le processus.
Le concept est trè s similaire dans l’esprit à une straté gie utilisé e pour l’entraînement des forê ts alé atoires, qui consiste
à sé lectionner alé atoirement des variables candidates pour chaque division d’arbre à l’inté rieur d’une forê t, ce qui est
connu pour conduire à de meilleures performances de gé né ralisation pour les forê ts alé atoires. La principale diffé rence
ici est que l’on peut non seulement dé sactiver les neurones d’entrée mais aussi les neurones de la couche cachée pendant
l’apprentissage.
Dans keras, ceci est implé menté comme une couche, qui agit en dé sactivant les neurones de la couche pré cé dente dans
le ré seau :

30 Chapitre 5. Régularisation
 Introduction au Deep Learning (notes de cours)

FІԌ. 5.1 – Illustration du mé canisme de DropOut. Afin d’entraîner un modè le donné (à gauche), à chaque minibatch, une
proportion donné e de neurones est choisie au hasard pour ê tre « dé sactivé e » et le sous-ré seau ré sultant est utilisé pour
l’é tape d’optimisation en cours (cf. figure de droite, dans laquelle 40% des neurones – coloré s en gris – sont dé sactivé s).

from keras.layers import Dropout

set_random_seed(0)
switchoff_proba = 0.3
model = Sequential([
InputLayer(input_shape=(4, )),
Dropout(rate=switchoff_proba),
Dense(units=256, activation="relu"),
Dropout(rate=switchoff_proba),
Dense(units=256, activation="relu"),
Dropout(rate=switchoff_proba),
Dense(units=256, activation="relu"),
Dropout(rate=switchoff_proba),
Dense(units=3, activation="softmax")
])

n_epochs = 100
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
h = model.fit(X, y, validation_split=0.3, epochs=n_epochs, batch_size=30, verbose=0)

5.3. DropOut 31
Introduction au Deep Learning (notes de cours)

® Exercice #1

En observant les valeurs de perte dans la figure ci-dessus, pouvez-vous expliquer pourquoi la perte de validation est
presque systé matiquement infé rieure à celle calculé e sur le jeu d’apprentissage ?

® Solution

En fait, la perte d’apprentissage est calculé e comme la perte moyenne sur tous les minibatchs d’apprentissage
pendant une epoch. Si nous nous rappelons que pendant l’apprentissage, à chaque minibatch, 30% des neurones
sont dé sactivé s, on peut voir que seule une sous-partie du modè le complet est utilisé e lors de l’é valuation de la
perte d’apprentissage alors que le modè le complet est utilisé lors de la pré diction sur l’ensemble de validation, ce
qui explique pourquoi la perte de validation mesuré e est infé rieure à celle de l’apprentissage.

32 Chapitre 5. Régularisation
 CHAPITRE 6

RÉSEAUX NEURONAUX CONVOLUTIFS

Les ré seaux de neurones convolutifs (aussi appelé s ConvNets) sont conçus pour tirer parti de la structure des donné es.
Dans ce chapitre, nous aborderons deux types de ré seaux convolutifs : nous commencerons par le cas monodimensionnel
et verrons comment les ré seaux convolutifs à convolutions 1D peuvent ê tre utiles pour traiter les sé ries temporelles. Nous
pré senterons ensuite le cas 2D, particuliè rement utile pour traiter les donné es d’image.

6.1 Réseaux de neurones convolutifs pour les séries temporelles

Les ré seaux de neurones convolutifs pour les sé ries temporelles reposent sur l’opé rateur de convolution 1D qui, é tant
donné une sé rie temporelle x et un filtre f, calcule une carte d’activation comme :
𝐿
(x ∗ f) (𝑡) = ∑ 𝑓𝑘 𝑥𝑡+𝑘 (6.1)
𝑘=−𝐿

où le filtre f est de longueur (2𝐿 + 1).

Le code suivant illustre cette notion en utilisant un filtre gaussien :
Les ré seaux de neurones convolutifs sont constitué s de blocs de convolution dont les paramè tres sont les coefficients des
filtres qu’ils intè grent (les filtres ne sont donc pas fixé s a priori comme dans l’exemple ci-dessus mais plutô t appris). Ces
blocs de convolution sont é quivariants par translation, ce qui signifie qu’un dé calage (temporel) de leur entré e entraîne le
mê me dé calage temporel de leur sortie :

/tmp/ipykernel_7364/1028966743.py:32: UserWarning: This figure includes Axes that␣

↪are not compatible with tight_layout, so results might be incorrect.

plt.tight_layout()

<IPython.core.display.HTML object>

Les modè les convolutifs sont connus pour ê tre trè s performants dans les applications de vision par ordinateur, utilisant
des quantité s modé ré es de paramè tres par rapport aux modè les entiè rement connecté s (bien sû r, des contre-exemples
existent, et le terme « modé ré » est particuliè rement vague).

33
Introduction au Deep Learning (notes de cours)

La plupart des architectures standard de sé ries temporelles qui reposent sur des blocs convolutionnels sont des adaptations
directes de modè les de la communauté de la vision par ordinateur ([Le Guennec et al., 2016] s’appuie sur une alternance
entre couches de convolution et couches de pooling, tandis que des travaux plus ré cents s’appuient sur des connexions
ré siduelles et des modules d”inception [Fawaz et al., 2020]). Ces blocs de base (convolution, pooling, couches ré siduelles)
sont discuté s plus en dé tail dans la section suivante.
Ces modè les de classification des sé ries temporelles (et bien d’autres) sont pré senté s et é valué s dans [Fawaz et al., 2019]
que nous conseillons au lecteur inté ressé .

6.2 Réseaux de neurones convolutifs pour les images

Nous allons maintenant nous inté resser au cas 2D, dans lequel les filtres de convolution ne glisseront pas sur un seul axe
comme dans le cas des sé ries temporelles, mais plutô t sur les deux dimensions (largeur et hauteur) d’une image.

6.2.1 Images et convolutions

Comme on le voit ci-dessous, une image est une grille de pixels, et chaque pixel a une valeur d’intensité dans chacun des
canaux de l’image. Les images couleur sont typiquement composé es de 3 canaux (ici Rouge, Vert et Bleu).

FІԌ. 6.1 – Une image et ses 3 canaux (intensité s de Rouge, Vert et Bleu, de gauche à droite).

La sortie d’une convolution sur une image x est une nouvelle image, dont les valeurs des pixels peuvent ê tre calculé es
comme suit :
𝐾 𝐿 3
(x ∗ f) (𝑖, 𝑗) = ∑ ∑ ∑ 𝑓𝑘,𝑙,𝑐 𝑥𝑖+𝑘,𝑗+𝑙,𝑐 . (6.2)
𝑘=−𝐾 𝑙=−𝐿 𝑐=1

En d’autres termes, les pixels de l’image de sortie sont calculé s comme le produit scalaire entre un filtre de convolution
(qui est un tenseur de forme (2𝐾 + 1, 2𝐿 + 1, 𝑐)) et un patch d’image centré à la position donné e.
Considé rons, par exemple, le filtre de convolution 9x9 suivant :

34 Chapitre 6. Réseaux neuronaux convolutifs

 Introduction au Deep Learning (notes de cours)

Le ré sultat de la convolution de l’image de chat ci-dessus avec ce filtre est l’image suivante en niveaux de gris (c’est-à -dire
constitué e d’un seul canal) :

On peut remarquer que cette image est une version floue de l’image originale. C’est parce que nous avons utilisé un filtre
Gaussien. Comme pour les sé ries temporelles, lors de l’utilisation d’opé rations de convolution dans les ré seaux neuronaux,
le contenu des filtres sera appris, plutô t que dé fini a priori.

6.2. Réseaux de neurones convolutifs pour les images 35

Introduction au Deep Learning (notes de cours)

6.2.2 Réseaux convolutifs de type LeNet

Dans [LeCun et al., 1998], un empilement de couches de convolution, de pooling et de couches entiè rement connecté es
est introduit pour une tâ che de classification d’images, plus spé cifiquement une application de reconnaissance de chiffres.
Le ré seau neuronal ré sultant, appelé LeNet, est repré senté ci-dessous :

FІԌ. 6.2 – Modè le LeNet-5

Couches de convolution

Une couche de convolution est constitué e de plusieurs filtres de convolution (é galement appelé s kernels) qui opè rent
en parallè le sur la mê me image d’entré e. Chaque filtre de convolution gé nè re une carte d’activation en sortie et toutes
ces cartes sont empilé es pour former la sortie de la couche de convolution. Tous les filtres d’une couche partagent la
mê me largeur et la mê me hauteur. Un terme de biais et une fonction d’activation peuvent ê tre utilisé s dans les couches de
convolution, comme dans d’autres couches de ré seaux neuronaux. Dans l’ensemble, la sortie d’un filtre de convolution est
calculé e comme suit :
𝐾 𝐿
𝑐
(x ∗ f) (𝑖, 𝑗, 𝑐) = 𝜑 ( ∑ ∑ ∑ 𝑓𝑘,𝑙,𝑐 ′ 𝑥𝑖+𝑘,𝑗+𝑙,𝑐′ + 𝑏𝑐 ) (6.3)
𝑘=−𝐾 𝑙=−𝐿 𝑐′

où 𝑐 dé signe le canal de sortie (notez que chaque canal de sortie est associé à un filtre 𝑓 𝑐 ), 𝑏𝑐 est le terme de biais qui lui
est associé et 𝜑 est la fonction d’activation utilisé e.

b Astuce

En keras, une telle couche est implé menté e à l’aide de la classe Conv2D :
import keras
from keras.layers import Conv2D

layer = Conv2D(filters=6, kernel_size=5, padding="valid", activation="relu")

® Padding

36 Chapitre 6. Réseaux neuronaux convolutifs

 Introduction au Deep Learning (notes de cours)

FІԌ. 6.3 – Visualisation de l’effet du padding (source: V. Dumoulin, F. Visin - A guide to convolution arithmetic for
deep learning). Gauche: sans padding, droite: avec padding.

Lors du traitement d’une image d’entré e, il peut ê tre utile de s’assurer que la carte de caracté ristiques (ou carte d’ac-
tivation) de sortie a la mê me largeur et la mê me hauteur que l’image d’entré e. Cela peut ê tre ré alisé en agrandissant
artificiellement l’image d’entré e et en remplissant les zones ajouté es avec des zé ros, comme illustré dans Fig. 6.3 dans
lequel la zone de padding est repré senté e en blanc.

Couches de pooling

Les couches de pooling effectuent une opé ration de sous-é chantillonnage qui ré sume en quelque sorte les informations
contenues dans les cartes de caracté ristiques dans des cartes à plus faible ré solution.
L’idé e est de calculer, pour chaque parcelle d’image, une caracté ristique de sortie qui calcule un agré gat des pixels de
la parcelle. Les opé rateurs d’agré gation typiques sont les opé rateurs de moyenne (dans ce cas, la couche correspondante
est appelé e average pooling) ou de maximum (pour les couches de max pooling). Afin de ré duire la ré solution des cartes
de sortie, ces agré gats sont gé né ralement calculé s sur des fenê tres glissantes qui ne se chevauchent pas, comme illustré
ci-dessous, pour un max pooling avec une taille de pooling de 2x2 :

6.2. Réseaux de neurones convolutifs pour les images 37

Introduction au Deep Learning (notes de cours)

max

Ces couches é taient largement utilisé es historiquement dans les premiers modè les convolutifs et le sont de moins en moins
à mesure que la puissance de calcul disponible augmente.

b Astuce

En keras, les couches de pooling sont implé menté es à travers les classes MaxPool2D et AvgPool2D :
from keras.layers import MaxPool2D, AvgPool2D

max_pooling_layer = MaxPool2D(pool_size=2)
average_pooling_layer = AvgPool2D(pool_size=2)

Ajout d’une tête de classification

Un empilement de couches de convolution et de pooling produit une carte d’activation structuré e (qui prend la forme d’une
grille 2d avec une dimension supplé mentaire pour les diffé rents canaux). Lorsque l’on vise une tâ che de classification
d’images, l’objectif est de produire la classe la plus probable pour l’image d’entré e, ce qui est gé né ralement ré alisé par une
tê te de classification (classification head) composé e de couches entiè rement connecté es.
Pour que la tê te de classification soit capable de traiter une carte d’activation, les informations de cette carte doivent ê tre
transformé es en un vecteur. Cette opé ration est appelé e Flatten dans keras, et le modè le correspondant à Fig. 6.2 peut
ê tre implé menté comme :

from keras.models import Sequential

from keras.layers import InputLayer, Conv2D, MaxPool2D, Flatten, Dense

model = Sequential([
(suite sur la page suivante)

38 Chapitre 6. Réseaux neuronaux convolutifs

 Introduction au Deep Learning (notes de cours)

(suite de la page pré cé dente)

InputLayer(input_shape=(32, 32, 1)),
Conv2D(filters=6, kernel_size=5, padding="valid", activation="relu"),
MaxPool2D(pool_size=2),
Conv2D(filters=16, kernel_size=5, padding="valid", activation="relu"),
MaxPool2D(pool_size=2),
Flatten(),
Dense(120, activation="relu"),
Dense(84, activation="relu"),
Dense(10, activation="softmax")
])
model.summary()

Model: "sequential"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type) ┃ Output Shape ┃ Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ conv2d (Conv2D) │ (None, 28, 28, 6) │ 156 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d (MaxPooling2D) │ (None, 14, 14, 6) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_1 (Conv2D) │ (None, 10, 10, 16) │ 2,416 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_1 (MaxPooling2D) │ (None, 5, 5, 16) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten (Flatten) │ (None, 400) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense (Dense) │ (None, 120) │ 48,120 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_1 (Dense) │ (None, 84) │ 10,164 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_2 (Dense) │ (None, 10) │ 850 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

Total params: 61,706 (241.04 KB)

Trainable params: 61,706 (241.04 KB)

Non-trainable params: 0 (0.00 B)

6.2. Réseaux de neurones convolutifs pour les images 39

Introduction au Deep Learning (notes de cours)

40 Chapitre 6. Réseaux neuronaux convolutifs

 CHAPITRE 7

RÉSEAUX NEURONAUX RÉCURRENTS

Les ré seaux neuronaux ré currents (RNN) traitent les é lé ments d’une sé rie temporelle un par un. Typiquement, à l’instant
𝑡, un bloc ré current prend en entré e :
— l’entré e courante 𝑥𝑡 et
— un é tat caché ℎ𝑡−1 qui a pour but de ré sumer les informations clé s provenant de des entré es passé es {𝑥0 , … , 𝑥𝑡−1 }
Ce bloc retourne un é tat caché mis à jour ℎ𝑡 :

ℎ𝑡−1 ℎ𝑡 ℎ𝑡+1

… …

𝑥𝑡−1 𝑥𝑡 𝑥𝑡+1
Il existe diffé rentes couches ré currentes qui diffè rent principalement par la façon dont ℎ𝑡 est calculé e.

41
Introduction au Deep Learning (notes de cours)

7.1 Réseaux récurrents standard

La formulation originale d’une RNN est la suivante :

∀𝑡, ℎ𝑡 = tanh(𝑊ℎ ℎ𝑡−1 + 𝑊𝑥 𝑥𝑡 + 𝑏) (7.1)

où 𝑊ℎ est une matrice de poids associé e au traitement de l’é tat caché pré cé dent, 𝑊𝑥 est une autre matrice de poids
associé e au traitement de la l’entré e actuelle et 𝑏 est un terme de biais.
On notera ici que 𝑊ℎ , 𝑊𝑥 et 𝑏 ne sont pas indexé s par 𝑡, ce qui signifie que qu’ils sont partagés entre tous les temps.
Une limitation importante de cette formule est qu’elle é choue à capturer les dé pendances à long terme. Pour mieux
comprendre pourquoi, il faut se rappeler que les paramè tres de ces ré seaux sont optimisé s par des algorithmes de descente
de gradient stochastique.
Pour simplifier les notations, considé rons un cas simplifié dans lequel ℎ𝑡 et 𝑥𝑡 sont tous deux des valeurs scalaires, et
regardons ce que vaut le gradient de la sortie ℎ𝑡 par rapport à 𝑊ℎ (qui est alors aussi un scalaire) :

′ 𝜕𝑜𝑡
∇𝑊ℎ (ℎ𝑡 ) = tanh (𝑜𝑡 ) ⋅ (7.2)
𝜕𝑊ℎ

où 𝑜𝑡 = 𝑊ℎ ℎ𝑡−1 + 𝑊𝑥 𝑥𝑡 + 𝑏, donc:

𝜕𝑜𝑡 𝜕ℎ𝑡−1
= ℎ𝑡−1 + 𝑊ℎ ⋅ . (7.3)
𝜕𝑊ℎ 𝜕𝑊ℎ
𝜕ℎ𝑡−1
Ici, la forme de 𝜕𝑊ℎ sera similaire à celle de ∇𝑊ℎ (ℎ𝑡 ) ci-dessus, et, au final, on obtient :

′ 𝜕ℎ𝑡−1
∇𝑊ℎ (ℎ𝑡 ) = tanh (𝑜𝑡 ) ⋅ [ℎ𝑡−1 + 𝑊ℎ ⋅ ] (7.4)
𝜕𝑊ℎ
′ ′
= tanh (𝑜𝑡 ) ⋅ [ℎ𝑡−1 + 𝑊ℎ ⋅ tanh (𝑜𝑡−1 ) ⋅ [ℎ𝑡−2 + 𝑊ℎ ⋅ [… ]]] (7.5)
′ ′ ′
= ℎ𝑡−1 tanh (𝑜𝑡 ) + ℎ𝑡−2 𝑊ℎ tanh (𝑜𝑡 )tanh (𝑜𝑡−1 ) + … (7.6)
𝑡−1
′ ′ ′
= ∑ ℎ𝑡′ [𝑊ℎ𝑡−𝑡 −1 tanh (𝑜𝑡′ +1 ) ⋅ ⋯ ⋅ tanh (𝑜𝑡 )] (7.7)
𝑡′ =1

′ ′ ′
En d’autres termes, l’influence de ℎ𝑡′ sera atté nué e par un facteur 𝑊ℎ𝑡−𝑡 −1 tanh (𝑜𝑡′ +1 ) ⋅ ⋯ ⋅ tanh (𝑜𝑡 ).
Rappelons maintenant à quoi ressemblent la fonction tanh et sa dé rivé e :

42 Chapitre 7. Réseaux neuronaux récurrents

 Introduction au Deep Learning (notes de cours)

On peut voir à quel point les gradients se rapprochent rapidement de 0 pour des entré es plus grandes (en valeur absolue)
que 2, et avoir plusieurs termes de ce type dans une dé rivation en chaîne fera tendre les termes correspondants vers 0.
En d’autres termes, le gradient de l’é tat caché au temps 𝑡 sera seulement influencé par quelques uns de ses pré dé cesseurs
{ℎ𝑡−1 , ℎ𝑡−2 , … } et les les dé pendances à long terme seront ignoré es lors de l’actualisation des paramè tres du modè le par
descente de gradient. Il s’agit d’une occurrence d’un phé nomè ne plus gé né ral connu sous le nom de vanishing gradient.

7.2 Long Short Term Memory

Les blocs Long Short Term Memory (LSTM, [Hochreiter and Schmidhuber, 1997]) ont é té conçus comme une alternative
à aux blocs ré currents classiques. Ils visent à atté nuer l’effet de vanishing gradient par l’utilisation de portes qui codent
explicitement quelle partie de l’information doit (resp. ne doit pas) ê tre utilisé e.

® Les portes dans les réseaux neuronaux

Dans la terminologie des ré seaux de neurones, une porte 𝑔 ∈ [0, 1]𝑑 est un vecteur utilisé pour filtrer les informations
d’un vecteur caracté ristique entrant 𝑣 ∈ ℝ𝑑 de telle sorte que le ré sultat de l’application de la porte est : 𝑔 ⊙ 𝑣. où ⊙
est le produit é lé ment-par-é lé ment. La porte 𝑔 aura donc tendance à supprimer une partie des caracté ristiques de 𝑣.
(celles qui correspondent à des valeurs trè s faibles de 𝑔).

Dans ces blocs, un é tat supplé mentaire est utilisé , appelé é tat de la cellule 𝐶𝑡 . Cet é tat est calculé comme suit :

𝐶𝑡 = 𝑓𝑡 ⊙ 𝐶𝑡−1 + 𝑖𝑡 ⊙ 𝐶𝑡̃ (7.8)

où 𝑓𝑡 est appelé e forget gate (elle pousse le ré seau à oublier les parties inutiles de l’é tat passé de la cellule), 𝑖𝑡 est l”input

7.2. Long Short Term Memory 43

Introduction au Deep Learning (notes de cours)

gate et 𝐶𝑡̃ est une version actualisé e de l’é tat de la cellule (qui, à son tour, peut ê tre partiellement censuré e par l”input
gate).
Laissons de cô té pour l’instant les dé tails concernant le calcul de ces 3 termes et concentrons-nous plutô t sur la façon dont
la formule ci-dessus est est significativement diffé rente de la rè gle de mise à jour de l’é tat caché dans le modè le classique.
En effet, dans ce cas, si le ré seau l’apprend (par l’intermé diaire de 𝑓𝑡 ), l’information complè te de l’é tat pré cé dent de la
cellule 𝐶𝑡−1 peut ê tre ré cupé ré e, ce qui permet aux gradients de se propager à rebours de l’axe du temps (et de ne plus
disparaître).
Alors, le lien entre l’é tat de la cellule et l’é tat caché est :

ℎ𝑡 = 𝑜𝑡 ⊙ tanh(𝐶𝑡 ) . (7.9)

En d’autres termes, l’é tat caché est la version transformé e (par la fonction tanh) de l’é tat de la cellule, encore censuré par
une porte de sortie (output gate) 𝑜𝑡 .
Toutes les portes utilisé es dans les formules ci-dessus sont dé finies de maniè re similaire :

𝑓𝑡 = 𝜎(𝑊𝑓 ⋅ [ℎ𝑡−1 , 𝑥𝑡 ] + 𝑏𝑓 ) (7.10)

𝑖𝑡 = 𝜎(𝑊𝑖 ⋅ [ℎ𝑡−1 , 𝑥𝑡 ] + 𝑏𝑖 ) (7.11)
𝑜𝑡 = 𝜎(𝑊𝑜 ⋅ [ℎ𝑡−1 , 𝑥𝑡 ] + 𝑏𝑜 ) (7.12)

où 𝜎 est la fonction d’activation sigmoïde (dont les valeurs sont comprises dans [0, 1]) et [ℎ𝑡−1 , 𝑥𝑡 ] la concaté nation des
caracté ristiques ℎ𝑡−1 et 𝑥𝑡 .
Enfin, l’é tat de cellule mis à jour 𝐶𝑡̃ est calculé comme suit :

𝐶𝑡̃ = tanh(𝑊𝐶 ⋅ [ℎ𝑡−1 , 𝑥𝑡 ] + 𝑏𝐶 ) . (7.13)

Il existe dans la litté rature de nombreuses variantes de ces blocs LSTM qui reposent toujours sur les mê mes principes de
base.

7.3 Gated Recurrent Unit

Une paramé trisation lé gè rement diffé rente d’un bloc ré current est utilisé e dans les Gated Recurrent Units (GRU, [Cho et
al., 2014]).
Les GRUs reposent é galement sur l’utilisation de portes pour laisser (de maniè re adaptative) l’information circuler à
travers le temps. Une premiè re diffé rence significative entre les GRUs et les LSTMs est que les GRUs n’ont pas recours
à l’utilisation d’un é tat de cellule. Au lieu de cela, la rè gle de mise à jour de l’é tat caché est la suivante :

ℎ𝑡 = (1 − 𝑧𝑡 ) ⊙ ℎ𝑡−1 + 𝑧𝑡 ⊙ ℎ̃ 𝑡 (7.14)

où 𝑧𝑡 est une porte qui é quilibre (par caracté ristique) la quantité d’informations qui est conservé e de l’é tat caché pré cé dent
avec la quantité d’informations qui doit ê tre mise à jour en utilisant le nouvel é tat caché candidat ℎ̃ 𝑡 , calculé comme suit :

ℎ̃ 𝑡 = tanh(𝑊 ⋅ [𝑟𝑡 ⊙ ℎ𝑡−1 , 𝑥𝑡 ] + 𝑏) , (7.15)

où 𝑟𝑡 est une porte supplé mentaire qui peut cacher une partie de l’é tat caché pré cé dent.
Les formules pour les portes 𝑧𝑡 et 𝑟𝑡 sont similaires à celles fournies pour 𝑓𝑡 , 𝑖𝑡 et 𝑜𝑡 dans le cas des LSTMs.
Une é tude graphique de la capacité de ces variantes de ré seaux ré currents à apprendre des dé pendances à long terme est
fournie dans [Madsen, 2019].

44 Chapitre 7. Réseaux neuronaux récurrents

 Introduction au Deep Learning (notes de cours)

7.4 Conclusion

Dans ce chapitre et le pré cé dent, nous avons passé en revue les architectures de ré seaux de neurones qui sont utilisé es
pour apprendre à partir de donné es temporelles ou sé quentielles. En raison de contraintes de temps, nous n’avons pas
abordé les modè les basé s sur l’attention dans ce cours. Nous avons pré senté les modè les convolutifs qui visent à extraire
des formes locales discriminantes dans les sé ries et les modè les ré currents qui exploitent plutô t la notion de sé quence.
Concernant ces derniers, des variantes visant à faire face à l’effet de gradient é vanescent ont é té introduites. Il est à noter
que les modè les ré currents sont connus pour né cessiter plus de donné es d’entraînement que leurs homologues convolutifs.

7.4. Conclusion 45
Introduction au Deep Learning (notes de cours)

46 Chapitre 7. Réseaux neuronaux récurrents

 CHAPITRE 8

MÉCANISME D’ATTENTION

Dans de nombreux contextes d’apprentissage profond (traduction automatique, ré sumé de texte, traitement de sé quences)
les modè les doivent manipuler des entré es de taille variable et se concentrer sur certaines parties plus que d’autres.
Le mé canisme d”attention permet justement de donner plus de poids à certains é lé ments d’une sé quence lors du calcul
d’une sortie, en fonction de leur pertinence.

8.1 Motivation

Considé rons la phrase suivante :

« An apple that had been on the tree in the garden for weeks had finally been picked up. »
qui en français pourrait se traduire par :
« Une pomme qui était sur l’arbre du jardin depuis des semaines avait finalement été ramassée. »
Ici, pour bien orthographier le mot ramassée, il faut avoir conscience qu’il fait ré fé rence au nom une pomme qui est
fé minin.
Pour qu’un modè le de traduction automatique soit capable d’orthographier correctement ce mot, il faut donc qu’il soit
capable de modé liser des dépendances à longue portée entre les mots.
Or, les architectures récurrentes ou convolutives classiques ont du mal à gé rer efficacement ces dé pendances à cause :
— du goulot d’étranglement (bottleneck) dans les repré sentations,
— de la difficulté à mé moriser des informations é loigné es.
L’attention ré pond à cette limite en permettant au modè le de se focaliser dynamiquement sur certaines entré es au mo-
ment de produire une sortie.

47
Introduction au Deep Learning (notes de cours)

8.2 Principe général

Au lieu de ré sumer l’entré e par un seul vecteur fixe, comme dans les encodeurs ré currents classiques, l’attention gé nè re
une sortie en pondérant les différentes parties de l’entrée selon leur pertinence.
Pour chaque é lé ment de la sortie, le modè le effectue une agrégation pondérée des é lé ments d’entré e, où les poids reflè tent
leur importance.

8.3 Métaphore : Queries, Keys, Values

L’attention peut ê tre interpré té e via la mé taphore suivante :

— Query (Q) : ce que l’on cherche
— Key (K) : ce que l’on a comme ré fé rence
— Value (V) : ce que l’on extrait
On peut rapprocher ce mé canisme de ce qui se passe lorqu’on manipule un dictionnaire Python : dans un dictionnaire,
on cherche une clé exacte pour obtenir la valeur associé e. Ici, la requê te joue le rô le de la clé recherché e, mais au lieu
d’une correspondance exacte, on compare la requê te à toutes les clé s disponibles (qui sont des vecteurs numé riques) en
mesurant leur similarité (typiquement via un produit scalaire).
Plutô t que de ré cupé rer la valeur d’une seule clé , on effectue une moyenne pondérée des valeurs associé es aux clé s les
plus similaires à la requê te. Les poids de cette moyenne sont justement les similarité s calculé es entre la requê te et chaque
clé .

8.4 Formulation mathématique

Soient deux sé quences de vecteurs d’entré e 𝑋 = [𝑥1 , … , 𝑥𝑛 ] et 𝑌 = [𝑦1 , … , 𝑦𝑚 ]. L’attention consiste à projeter 𝑋 en
requê tes 𝑄 et 𝑌 en clé s 𝐾 et valeurs 𝑉 :

𝑄 = 𝑋𝑊 𝑄
𝐾 = 𝑌 𝑊𝐾
𝑉 = 𝑌 𝑊𝑉

où 𝑊 𝑄 , 𝑊 𝐾 , 𝑊 𝑉 sont des matrices de poids apprises.

L’attention est alors dé finie par :

𝑄𝐾 𝑇
Attention(𝑄, 𝐾, 𝑉 ) = softmax ( )𝑉
√𝑑𝑘

où 𝑑𝑘 est la dimension des vecteurs clé s (utilisé pour stabiliser l’entraînement).

import torch
import numpy as np
import torch.nn.functional as F

torch.manual_seed(0)

Q = torch.randn(1, 4, 8) # batch, longueur, dim

K = torch.randn(1, 6, 8) # les clés ne sont pas forcément de la même longueur
V = torch.randn(1, 6, 10) # la longueur des valeurs est celle des clés, leur dim peut␣
(suite sur la page suivante)

48 Chapitre 8. Mécanisme d’attention

 Introduction au Deep Learning (notes de cours)

(suite de la page pré cé dente)

↪être autre

scores = torch.matmul(Q, K.transpose(-2, -1)) / np.sqrt(8)

weights = F.softmax(scores, dim=-1)
output = torch.matmul(weights, V)

output.shape # (1, 4, 10)

torch.Size([1, 4, 10])

8.5 Auto-attention (ou self-attention)

Dans certains cas, comme en traitement de sé quence, les entré es 𝑋 et 𝑌 ne sont qu’une seule et mê me sé quence (on
souhaite comparer les é lé ments de la sé quence deux à deux) : on parle alors de self-attention.
Cela signifie que chaque position de la sé quence 𝑋 « regarde » toutes les autres positions de cette mê me sé quence pour
construire sa propre repré sentation.

8.6 Multi-head attention

En pratique, dans la plupart des modè les, le mé canisme d’attention est dupliqué plusieurs fois (avec des poids diffé rents)
et leurs sorties sont concaté né es : on parle alors de multi-head attention. Cela permet, d’une part, à chaque head de se
focaliser sur des aspects diffé rents de la sé quence (syntaxe, structure, position, etc.). Au final, cela permet une modé lisation
plus riche des dé pendances.

8.7 Schéma général

8.8 Résumé

— Le mé canisme d’attention permet de capturer les dé pendances entre é lé ments d’une sé quence sans contrainte de
distance.
— Il repose sur le calcul de similarité entre requê tes et clé s, et la pondé ration des valeurs associé es.
— Il est à la base des modè les Transformer, aujourd’hui omnipré sents en NLP et en vision.

8.5. Auto-attention (ou self-attention) 49

Introduction au Deep Learning (notes de cours)

FІԌ. 8.1 – Sché ma d’un bloc Transformer avec multi-head attention (source : HuggingFace).

50 Chapitre 8. Mécanisme d’attention

 CHAPITRE 9

RÉSEAUX NEURONAUX GÉNÉRATIFS

Les modè les gé né ratifs ont pour objectif d’apprendre la distribution des donné es d’entraînement. Cette distribution peut
ê tre estimé e de façon explicite, en apprenant une forme paramé trique de 𝑝(𝑥) ou de la probabilité conditionnelle 𝑝(𝑥|𝑦),
ou bien approché e de maniè re implicite, sans forme close mais en permettant l’é chantillonnage de nouvelles donné es.
Parmi les principaux modè les gé né ratifs, on retrouve les modè les de mé lange gaussiens (GMM), les auto-encodeurs
variationnels (VAE), les ré seaux adversaires gé né ratifs (GAN) et les modè les de diffusion. Chacun de ces modè les propose
une approche diffé rente pour modé liser et gé né rer des donné es, allant de l’estimation directe de la distribution à des
mé thodes plus indirectes basé es sur l’é chantillonnage ou la compé tition entre ré seaux.

9.1 Auto-encodeurs

Les auto-encodeurs [Hinton and Salakhutdinov, 2006] sont des ré seaux qui apprennent à compresser l’information dans
un espace latent. Un auto-encodeur est constitué d’un bloc Encodeur et d’un Bloc Dé codeur, utilisé s comme suit :

𝑧 =Encodeur(𝑥) (9.1)
𝑥̂ =Decodeur(𝑧) (9.2)

Autrement dit, un encodeur projette l’entré e 𝑥 vers une repré sentation latente 𝑧, gé né ralement de plus faible dimension,
puis un dé codeur reconstruit une approximation 𝑥̂ à partir de 𝑧. Ce fonctionnement peut ê tre vu comme une gé né ralisation
de l’ACP au cas non liné aire. Toutefois, un auto-encodeur standard n’est pas un modè le gé né ratif, car il n’impose pas de
distribution particuliè re sur l’espace latent 𝑧 et n’offre donc pas de façon de tirer de nouveaux samples.

51
Introduction au Deep Learning (notes de cours)

9.2 Variational Auto-Encoders (VAE)

Les VAE [Kingma and Welling, 2014] transforment l’auto-encodeur en modè le gé né ratif en imposant un a priori sur la
variable latente 𝑧, typiquement une loi normale 𝑧 ∼ 𝒩(0, 𝐼). Une pé nalisation, sous forme de divergence de Kullback-
Leibler (KL), est ajouté e à la fonction de perte à optimiser pour encourager la distribution latente à respecter cet a priori.
Pour gé né rer de nouvelles donné es :
1. on tire un 𝑧 selon 𝒩(0, 𝐼)
2. on calcule 𝑥gen = Decodeur(𝑥)

9.3 Generative Adversarial Networks (GAN)

Proposé s par [Goodfellow et al., 2014], les GAN entraînent deux ré seaux :
— un Gé né rateur 𝐺 qui produit 𝑥fake = 𝐺(𝑧) à partir de bruit 𝑧 ∼ 𝒩(0, 𝐼)
— un Discriminateur 𝐷 qui pré dit si une entré e 𝑥 est ré elle (𝑦 = 1) ou gé né ré e (𝑦 = 0)
La fonction de perte optimisé e est la suivante :

𝔼𝑥∼𝑝𝑟 [log 𝐷(𝑥)] + 𝔼𝑧∼𝑝𝑧 [log(1 − 𝐷(𝐺(𝑧)))] (9.3)

Concrè tement, l’entraînement alterne entre mise à jour de 𝐷 (meilleure discrimination, maximisation de la fonction de
perte) et mise à jour de 𝐺 (meilleure gé né ration, minimisation de la fonction de perte).
Pour la gé né ration, comme pour un VAE, on tire un 𝑧 ∼ 𝒩(0, 𝐼) puis on le fournit en entré e au gé né rateur pour gé né rer
un nouveau sample 𝐺(𝑧).
En pratique, l’optimisation d’un GAN est souvent instable, et il est souvent né cessaire d’utiliser des astuces pour le stabiliser
(cf les Wasserstein GAN par exemple [Arjovsky et al., 2017]).

9.4 Modèles de diffusion

Les modè les de diffusion, introduits par [Ho et al., 2020], reposent sur une idé e originale : on ajoute progressivement du
bruit gaussien aux donné es, puis on entraîne un modè le à inverser ce processus, c’est-à -dire à dé bruiter les donné es é tape
par é tape. Lors de la gé né ration, on part d’un bruit pur et on le transforme progressivement en une donné e ré aliste.

9.5 Conditional Flow Matching

Le Conditional Flow Matching, proposé par [Lipman et al., 2023], consiste à apprendre un champ de vecteurs qui trans-
porte progressivement les é chantillons du bruit (é tat initial 𝑡 = 0, correspondant au 𝑧 introduit plus haut pour les VAE et
les GAN) vers les donné es ré elles (é tat final 𝑡 = 1, correspodant au 𝑥 plus haut). L’entraînement repose sur la minimisation
de la fonction de perte suivante :
𝔼𝑥0 ,𝑥1 ,𝑡 [𝑢𝜃 (𝑥, 𝑡) − (𝑥1 − 𝑥0 )] (9.4)
où 𝑥 = 𝑡𝑥0 + (1 − 𝑡)𝑥1 .
Une fois le modè le 𝑢𝜃 appris, la gé né ration s’effectue en ré solvant une é quation diffé rentielle, par exemple avec le sché ma
d’Euler, en partant d’un sample 𝑥0 tiré de 𝒩(0, 𝐼) :

𝑥𝑡+𝜀 ← 𝑥𝑡 + 𝜀𝑢𝜃 (𝑥𝑡 , 𝑡) (9.5)

Ce processus peut ê tre vu comme une interpolation guidé e entre le bruit et les donné es.

52 Chapitre 9. Réseaux neuronaux génératifs

 Introduction au Deep Learning (notes de cours)

9.6 Résumé

En ré sumé , les modè les gé né ratifs offrent des outils puissants pour modé liser et é chantillonner la distribution des don-
né es. Selon l’approche choisie, ils peuvent consister à compresser l’information en imposant une structure probabiliste sur
l’espace latent (VAE), à gé né rer des donné es par compé tition entre ré seaux (GAN), ou encore à produire des é chantillons
via des processus dynamiques et progressifs (diffusion et flow matching).

9.6. Résumé 53
Introduction au Deep Learning (notes de cours)

54 Chapitre 9. Réseaux neuronaux génératifs

 BIBLIOGRAPHIE

[Goh17] Gabriel Goh. Why momentum really works. Distill, 2017. URL: http://distill.pub/2017/momentum.
[KB15] Diederik P. Kingma and Jimmy Ba. Adam: a method for stochastic optimization. In Yoshua Bengio and
Yann LeCun, editors, ICLR. 2015.
[SHK+14] Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dro-
pout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research,
15(56):1929–1958, 2014. URL: http://jmlr.org/papers/v15/srivastava14a.html.
[FFW+19] Hassan Ismail Fawaz, Germain Forestier, Jonathan Weber, Lhassane Idoumghar, and Pierre-Alain Muller.
Deep learning for time series classification: a review. Data Mining and Knowledge Discovery, 33(4):917–
963, 2019.
[FLF+20] Hassan Ismail Fawaz, Benjamin Lucas, Germain Forestier, Charlotte Pelletier, Daniel F Schmidt, Jonathan
Weber, Geoffrey I Webb, Lhassane Idoumghar, Pierre-Alain Muller, and François Petitjean. Inception-
time: finding alexnet for time series classification. Data Mining and Knowledge Discovery, 34(6):1936–1962,
2020.
[LGMT16] Arthur Le Guennec, Simon Malinowski, and Romain Tavenard. Data Augmentation for Time Series Clas-
sification using Convolutional Neural Networks. In ECML/PKDD Workshop on Advanced Analytics and
Learning on Temporal Data. Riva Del Garda, Italy, September 2016.
[LBBH98] Yann LeCun, Lé on Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to docu-
ment recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
[CVMerrienboerBB14] Kyunghyun Cho, Bart Van Merrië nboer, Dzmitry Bahdanau, and Yoshua Bengio. On the pro-
perties of neural machine translation: encoder-decoder approaches. 2014. arXiv:1409.1259.
[HS97] Sepp Hochreiter and Jü rgen Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780,
1997.
[Mad19] Andreas Madsen. Visualizing memorization in rnns. Distill, 2019. URL: https://distill.pub/2019/
memorization-in-rnns.
[ACB17] Martin Arjovsky, Soumith Chintala, and Lé on Bottou. Wasserstein generative adversarial networks. In Pro-
ceedings of the International Conference on Machine Learning, 214–223. PMLR, 2017.
[GPAM+14] Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron
Courville, and Yoshua Bengio. Generative adversarial nets. In Neural Information Processing Systems. 2014.
[HS06] Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks.
Science, 313(5786):504–507, 2006.
[HJA20] Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. In Neural Information
Processing Systems. 2020.
[KW14] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114,
2014.

55
Introduction au Deep Learning (notes de cours)

[LCBH+23] Yaron Lipman, Ricky TQ Chen, Heli Ben-Hamu, Maximilian Nickel, and Matthew Le. Flow matching for
generative modeling. In Proceedings of the International Conference on Learning Representations. 2023.

56 Bibliographie