Cours Deep 1

Apprentissage statistique : modélisation
décisionnelle et apprentissage profond

(RCP209)
Introduction à l’apprentissage supervisé
Nicolas Audebert
nicolas.audebert@lecnam.net
http://cedric.cnam.fr/vertigo/Cours/ml2/
Département Informatique
Conservatoire National des Arts & Métiers, Paris, France
06 avril 2023
Introduction 1 / 75
Plan du cours
1 Introduction
2 Réseaux de neurones artificiels
3 Rétropropagation du gradient
4 Optimisation des réseaux profonds
5 Implémentation de la rétropropagation
6 Activations, régularisations, initialisations

Introduction 2 / 75
Données massives
Accès à de vastes quantités de données non-structurées : images, vidéos, sons,

textes, signaux, etc.
BBC : 2,4m vidéos Facebook : 350M images 100m caméras de surveillance
Besoin d’accéder à ces données, de les indexer, de les classer : reconnaissance

⇒ Sous quelle représentation ?
Introduction 3 / 75
Extraire du sens des signaux bas niveau
Problème : combler l’écart entre le signal et la sémantique.
Ce que l’humain perçoit

vs.
ce que la machine perçoit
Variations
d’illumination
Variations de points
de vue
Objets déformables
Variance et diversité
intra-classe
…
⇒ Comment concevoir de “bonnes”représentations des données ?

Introduction 4 / 75
Apprentissage statistique classique

Des données à la décison :
1 Choix de caractéristiques descriptives hand-crafted
descripteurs images (SIFT/HOG), coefficients audio (MFCC),
n-grammes/bag-of-words, etc.
nécessite des connaissances expertes du domaine
savoir a priori
2 Entraînement d’un modèle de décisionnel
3 Évaluation des performances
Introduction 4 / 75
Apprentissage statistique classique

Des données à la décison :
1 Choix de caractéristiques descriptives hand-crafted
descripteurs images (SIFT/HOG), coefficients audio (MFCC),
n-grammes/bag-of-words, etc.
nécessite des connaissances expertes du domaine
savoir a priori
2 Entraînement d’un modèle de décisionnel
3 Évaluation des performances
Apprentissage profond ⇒ apprentissage de représentations
Introduction 5 / 75
Historique des réseaux de neurones
1943 : Neurone artificiel McCulloch et Pitts 1943

1957 : Perceptron Rosenblatt 1957
1974 : Algorithme de rétropropagation Werbos 1975
1980 : Neocognitron (premier réseau “profond”) à poids partagés Fukushima 1980
1989 : LeNet-5 (premier réseau convolutif) LeCun et al. 1989
2011/2012 : DanNet/AlexNet (premiers modèles à l’état de l’art en reconnaissance
d’image) Cireşan, Meier et Schmidhuber 2012 ; Krizhevsky, Sutskever et
Hinton 2012
Introduction 6 / 75
Plan du cours

3 Réseaux convolutifs (CNN)
4 Réseaux convolutifs modernes
5 Réseaux récurrents (RNN)
6 Réseaux récurrents modernes
7 Reconnaissance d’image avancée
8 Apprentissage profond avancé
Pour approfondir
RCP211 : Intelligence artificielle avancée
Apprentissage par renforcement
Modèles génératifs profonds (GAN, VAE)
Robustesse et incertitude des réseaux profonds
RCP217 : Intelligence artificielle pour le multimédia
Traitement du langage naturel (NLP)
Séries temporelles, audio et vidéo
Systèmes de recommandations et graphes
Réseaux de neurones artificiels 6 / 75
Plan du cours
1 Introduction

Neurone formel
Modèle simplifié d’un neurone réel (1943)

McCulloch et Pitts 1943
Entrée : vecteur x ∈ Rm , x = {x1 , x2 , . . . , xm },
Poids wj , pondération de la connexion entre
l’entrée j et la sortie, ∑
Sortie ŷ ∈ R (scalaire), ŷ = mj=1 wj xj .
Expression matricielle :


x1
 
 x2 
ŷ = wT x = w1 w2 ··· wm  . 
 .. 
xm
Neurone artificiel
Fonction de x ∈ Rm vers ŷ ∈ R :
1 Fonction affine (linéaire plus translation par un biais b scalaire) : s = wT x + b
2 Fonction d’activation non-linéaire ϕ : R → R : ŷ = ϕ(s)
Expression du neurone artificiel “complet”

ŷ = ϕ wT x + b
Partie linéaire
P
m
Projection affine : s = w⊤ x + b = wi xi + b
i=1
w : vecteur à un hyperplan de Rm ⇒
s = 0 définit une frontière linéaire
bias b définit un écart par rapport à la position de l’hyperplan
Hyperplan en dimension 2 : droite Hyperplan en dimension 3 : plan

Fonction d’activation non-linéaire

ŷ = σ wT x + b
Fonction identité : ϕ(x) = x

(
1 six ≥ 0
Fonction de Heaviside (échelon) : ϕ(x) =
0 sinon
1
Sigmoïde : σ(x) = 1+e−x
ex −e−x
Tangente hyperbolique : tanh x = ex +e−x
(
x six ≥ 0
Rectified Linear Unit (ReLU) : ϕ(x) =
0 sinon
Lien avec les neurones biologiques
Neurone formel, activation Heaviside H : ŷ = H(w⊤ x + b)

ŷ = 1 (neurone actif) ⇔ w⊤ x ≥ −b
ŷ = 0 (neurone inactif) ⇔ w⊤ x < −b
Neurones biologiques : la sortie est active ⇔ la somme des entrées pondérées par le
poids des connexions est synaptique est supérieure à un seuil.
Activation sigmoïde
Équation du neurone artificiel : ŷ = ϕ(w⊤ x + b)

Sigmoïde : ϕ(z) = σa (z) = (1 + e−az )−1
a ↑ : se rapproche de l’échelon de Heaviside (a → ∞)

Sigmoïde : deux régimes
x ≈ 0 → régime linéaire (σ(x) ≈ ax)
x << 0 ou x >> 0 → régime de saturation (σ(x) ≈ ±1)
Application à la classification binaire
Chaque entrée x appartient soit à la classe 0, soit à la classe 1.

1
Sortie du neurone artificiel (sigmoïde) : ŷ = ⊤
1+e−a(w x+b)
Interprétation probabiliste ⇒ ŷ ∼ P(1|x)
L’entrée x est classée comme classe 1 si P(1|x) > 0.5 ⇔ w⊤ x + b > 0
L’entrée x est classée comme classe 0 si P(1|x) < 0.5 ⇔ w⊤ x + b < 0
⇒ signe(w⊤ x + b) : la frontière de classification est linéaire dans l’espace d’entrée !
Exemple jouet en 2D
En 2D (m = 2), x = {x1 , x2 } ∈ [−5; 5]2

Poids fixés w = [1; 1] et b = −2
Résultat de la fonction affine : s = w⊤ x + b = x1 + x2 − 2
⊤
−1
Activation non-linéaire, sigmoïde a = 10 : ŷ = 1 + e−a(w x+b)
Exemple jouet en 2D
En 2D (m = 2), x = {x1 , x2 } ∈ [−5; 5]2

⊤
−1
Exemple jouet en 2D
En 2D (m = 2), x = {x1 , x2 } ∈ [−5; 5]2

⊤
−1
Exemple jouet en 2D
En 2D (m = 2), x = {x1 , x2 } ∈ [−5; 5]2

⊤
−1
Activation non-linéaire, sigmoïde a = 0.1 : ŷ = 1 + e−a(w x+b)
Du neurone formel au réseau de neurones
Neurone artificiel :
1 Une seule sortie scalaire ŷ
2 Frontière linéaire pour la classification binaire
Sortie scalaire unique : expressivité limitée pour la
plupart des tâches
Comment gérer la classification multi-classe ?
⇒ utiliser plusieurs neurones de sortie plutôt qu’un seul !
⇒ modèle neuronal dit Perceptron (Rosenblatt 1957)
Du neurone formel au réseau de neurones
Neurone artificiel :
1 Une seule sortie scalaire ŷ
2 Frontière linéaire pour la classification binaire
Sortie scalaire unique : expressivité limitée pour la
plupart des tâches
Comment gérer la classification multi-classe ?
⇒ utiliser plusieurs neurones de sortie plutôt qu’un seul !
⇒ modèle neuronal dit Perceptron (Rosenblatt 1957)
Perceptron et classification multi-classe
Entrée x in Rm (“couche”d’entrée)
Chaque sortie yˆ1 est un neurone artificiel (“couche”de sortie). Par exemple, pour la
sortie yˆ1 :
Transformation affine : s1 = w1 T x + b1
Activation non-linéaire σ : yˆ1 = σ(s1 )
Paramètres de la transformation linéaire la sortie yˆ1 :
poids w1 = {w1,1 , w2,1 , . . . , wm,1 } ∈ Rm
biais b1 ∈ R
Perceptron et classification multi-classe
Entrée x in Rm
Chaque sortie yˆk est un neurone artificiel. Pour chaque sortie yˆk :
Transformation affine : sk = wk T x + bk
Activation non-linéaire σ : yˆk = σ(sk )
Paramètres de la transformation linéaire la sortie yˆk :
{ }
poids wk = w1,k , w2,k , . . . , wm,k ∈ Rm
biais bk ∈ R
Perceptron en résumé
Entrée x ∈ Rm (1 × m), sortie ŷ : concaténation de k neurones

Transformation affine (∼ multiplication matricielle) : s = xW + b
avec W une matrice de poids de dimensions m × k – les colonnes sont les vecteurs wk ,
et b le vecteur de biais – dimension 1 × k.
Activation non-linéaire élément par élément (pointwise) : ŷ = σ(s)
Application à la classification multi-classe

Comment généraliser la sigmoïde au cas à plusieurs classes ?
on cherche f telle que f(sj ) = P(j|x) (interprétation probabiliste)
∑
contrainte : kj=1 f(sj ) = 1.
Activation softmax :
e si
ŷi = f(si ) = Pk
j=1 e sj
⇒ on appelle ce modèle la régression logistique.

Exemple jouet en 2D pour trois classes
x = {x1 , x2 } ∈ [−5; 5] × [−5; 5], ŷ ∈ {0, 1, 2} (3 classes)

w1 = [1; 1], b1 = −2 w2 = [0; −1], b2 = 1 w3 = [1; −0.5], b3 = 10
Transformation
affine :
sk = wk T x + bk
Softmax :
P(k|x, W)
Exemple jouet en 2D pour trois classes
x = {x1 , x2 } ∈ [−5; 5] × [−5; 5], ŷ ∈ {0, 1, 2} (3 classes)

w1 = [1; 1], b1 = −2 w2 = [0; −1], b2 = 1 w3 = [1; −0.5], b3 = 10
Transformation
affine :
sk = wk T x + bk
Softmax :
P(k|x, W)
Classe prédite :
k∗ = arg maxP(k|x, W)
k
Limites du perceptron
Le problème du XOR
Régression logistique (LR) : perceptron à une couche d’entrée et une couche de
sortie
LR ne peut exprimer que des frontières de décisions linéaires
XOR : (NON 1 ET 2) OU (NON 2 ET 1)
La frontière optimale pour XOR est non-linéaire.
⇒ constat pessimiste : le perceptron échoue sur un problème en apparence très simple…

Au-delà des frontières linéaires

La régression logistique est limitée aux frontières linéaires.LR : limited to linear
boundaries
⇒ Solution : ajouter une couche de neurones !
Entrée : x ∈ Rm , ici par exemple m = 4.
Sortie : ŷ ∈ Rk (k classes), par ex. k = 2.
Couche “cachée” de taille l : h ∈ Rl , par ex. l = 5
Perceptron multi-couche
Couche cachée h : projection de

l’entrée x vers un nouvel espace Rl
h est une représentation intermédiaire
de x qui sera ensuite utilisée pour la
classification ŷ : h = ϕ (Ws h + bs ) par
la régression logistique.
Réseau de neurones avec au moins une
couche cachée : PMC, perceptron
multi-couche (multi-layer perceptron,
MLP)
Attention !
La non-linéarité de la fonction d’activation est indispensable pour le perceptron
multi-couche :
ŷ = ϕ (Ws h + bs ) et h = ϕ (We x + be )
⇒ ŷ = ϕ (Ws ϕ (We x + be ) + bs )
Si ϕ = Id, alors ŷ = ϕ (Ws We x + Ws be + bs )
équivalent à un perceptron classique avec W = Ws We et b = Ws be + bs !
Garanties théoriques
Quelle est l’expressivité des perceptrons multi-couche ?
Peut-on approcher n’importe quelle fonction à l’aide d’un PMC ?
Théorème d’approximation universelle

Soit f une fonction continue sur (des compacts de) Rd . Alors, pour tout ϵ > 0, il existe un
perceptron f̂ : x → Ws ϕ(W · x + b) multi-couche à une couche cachée de nombre de
neurones fini qui est une approximation de f à ϵ près, c’est-à-dire :
max∥f(x) − f̂(x)∥ < ϵ

x∈Rd
si ϕ est une fonction d’activation non-polynomiale.
Démontré pour les fonctions d’activation sigmoïde en 1989 Cybenko 1989

Étendu à l’ensemble des perceptrons multi-couche en 1991 Hornik 1991
D’autres résultats existent : profondeur arbitraire, largeur arbitraire, etc.
Limitations
Une seule couche cachée suffit mais le nombre de neurones n’est pas borné.
La démonstration prouve l’existence mais ne donne pas de méthode pour déterminer
les paramètres Ws , W et b.
Garanties théoriques
Quelle est l’expressivité des perceptrons multi-couche ?
Peut-on approcher n’importe quelle fonction à l’aide d’un PMC ?
Théorème d’approximation universelle

Soit f une fonction continue sur (des compacts de) Rd . Alors, pour tout ϵ > 0, il existe un
perceptron f̂ : x → Ws ϕ(W · x + b) multi-couche à une couche cachée de nombre de
neurones fini qui est une approximation de f à ϵ près, c’est-à-dire :
max∥f(x) − f̂(x)∥ < ϵ

x∈Rd
si ϕ est une fonction d’activation non-polynomiale.
Démontré pour les fonctions d’activation sigmoïde en 1989 Cybenko 1989

Étendu à l’ensemble des perceptrons multi-couche en 1991 Hornik 1991
D’autres résultats existent : profondeur arbitraire, largeur arbitraire, etc.
Limitations
Une seule couche cachée suffit mais le nombre de neurones n’est pas borné.
La démonstration prouve l’existence mais ne donne pas de méthode pour déterminer
les paramètres Ws , W et b.
Réseaux de neurones profonds

Augmenter le nombre de couche cachées : réseaux de neurones profonds (deep neural
networks)
Chaque couche hl projette les activations de la couche précédente hl−1 dans un
nouvel espace intermédiaire
⇒ construction incrémentale d’un espace intermédiaire de représentation utile pour la
tâche visée
l’apprentissage de représentation est la base de l’apprentissage profond !
En résumé
Neurone artificiel : représentation grossière d’un neurone biologique
Poids des connexions synaptiques
Fonction de transfert non-linéaire
Perceptron : une matrice de poids projetant la couche d’entrée vers la couche de
sortie
limité à des frontières de décision linéaires
Réseaux de neurones profonds : perceptrons multi-couche applicables aux problèmes
dont les frontières de décision sont non-linéaires
⇒ comment trouver les paramètres du modèle (poids des connexions) ? → apprentissage

supervisé
Rétropropagation du gradient 25 / 75
Plan du cours
1 Introduction

Algorithme du gradient
Soit f : Rd → R une fonction réelle à d variables différentiable.

On note ∇f(x) le gradient de f au point x = (x1 , x2 , . . . , xd ) ∈ Rd .

∂f ∂f ∂f
∇f = , ,··· ,
∂x1 ∂x2 ∂xd
Si ∇f(x∗ ) = 0, alors x∗ est un extremum local de f.
Si f est convexe ou concave, alors c’est un extremum global.
On cherche à minimiser f, c’est-à-dire trouver x∗ tel que f(x∗ ) < f(x) pour x ∈ Rd .
Algorithme du gradient Cauchy 1847

Soit x(0) ∈ Rd un point de départ et ϵ > 0. On définit la suite x(1) , x(2) , . . . telle que :
x(t+1) = x(t) − αt ∇f(x(t+1) )

Si ∥∇f(x(t) )∥ ≤ ϵ, on s’arrête.
αt peut être obtenu par divers moyens, comme une recherche linéaire. Dans notre
cas, on fixera αt = α > 0 constant.
Optimisation du multi-layer perceptron (MLP)

Entrée x ∈ Rm , sortie y ∈ Rp
Paramètres w (poids et biais du modèle)
Le MLP est un modèle paramétrique x ⇒ y : fw (xi ) = ŷi
Apprentissage supervisé : jeu d’entraînement annoté A = {(xi , y∗i )}i∈{1,2,...,N}
∑N
Fonction de coût L = i=1 ℓ(ŷi , y∗i ) entre la prédiction du modèle et l’annotation
Hypothèses : les paramètres w ∈ Rd sont des réels, L est différentiable.
Gradient ∇w = ∂L∂w
: direction de plus forte pente dans l’espace des paramètres
permettant de faire décroître le coût L
Algorithme d’optimisation
Considérons le vecteur des paramètres w ∈ Rd = (w1 , w2 , . . . , wd ).

Le gradient du coût L par rapport à w est le vecteur des dérivées partielles du coût par
rapport à chaque paramètre wi :
∗

∂L(ŷ,y∗ ;w) ∗
∇w L = ∂L(ŷ,y
∂w1
;w)
∂w2
· · · ∂L(ŷ,y∂w
;w)
d
Algorithme de la descente de gradient :

1 Initialisation aléatoire des paramètres w
(t+1) (t)
2 Mise à jour à l’itération t : wi = wi − η ∂w
∂L
i
3 Répéter l’étape 2 jusqu’à convergence, par ex. ∥∇w L∥2 ≈ 0 (le coût cesse de décroître).
Pas d’apprentissage
(t+1) (t)
Équation de mise à jour : wi = wi − η ∂w
∂L
i
η pas d’apprentissage (learning rate)
Peut-on garantir la convergence de l’algorithme vers un minimum ? ⇒

seulement pour une valeur de η “bien choisie”.
Minimum local ou global
(t+1) (t)
Équation de mise à jour : wi = wi − η ∂w
∂L
i
Le minimum trouvé est-il le meilleur (minimum global)?

⇒ garanti seulement si la fonction L(w) à minimiser est convexe
(a) Fonction convexe (b) Fonction non-convexe
dans la quasi-totalité des cas, la fonction de coût utilisée n’est pas convexe par
rapport aux paramètres du modèle…
Fonctions de coût pour le perceptron
Perceptron : ŷ = ϕ (xi W + b)
Régression :
Fonction de coût : L2 (MSE) ∥ŷ − y∥2 , L1 (MAE) |ŷ − y|, etc.
Classification multi-classe à K classes (régression logistique) :
y ∈ {1; 2; . . . ; K}
sk
Activation softmax : ϕ(sk ) = P(k|xi ) = ∑K e s
′ e k′
k =1
ŷi = arg max P(k|xi ; W, b)
k {
1 si ŷi ̸= y∗i
Fonction de coût : ℓ0/1 (ŷi , y∗i ) = : perte 0/1
0 sinon
⇒ non-différentiable !
Régression logistique : encodage des variables
Vérité terrain (étiquettes de supervision) y∗i ∈ {1, 2, . . . , K}

Encodage one hot pour chaque étiquette :
(
∗ 1 si c est la classe de xi
yc,i =
0 sinon
 
y∗i = 0, 0, . . . , 1
|{z} , . . . , 0
ce composante
Régression logistique : fonction de coût
Fonction de coût : entropie croisée (cross-entropy, CE) : ℓCE

ℓCE : divergence de Kullback-Leiber entre la distribution de probabilité y∗i de la vérité
terrain et la distribution prédite ^
yi
X
K
yi ) = KL(y∗i , ^
ℓCE (y∗i , ^ yi ) = − y∗c,i log(ŷc,i ) = − log(ŷc∗ ,i )
c=1
|{z}
∗
= 0 sauf pour c
Attention ! La divergence KL (et donc l’entropie croisée) est asymétrique :

KL(^yi , y∗i ) ̸= KL(y∗i , ^
yi )
Entraînement de la régression logistique
P P
LCE (W, b) = N1 Ni=1 ℓCE (ŷi , y∗i ) = − N1 Ni=1 log(ŷc ,i )
∗
ℓCE est une borne supérieure de la perte ℓ0/1

minimiser ℓCE ⇒ minimiser la perte ℓ0/1
ℓCE est différentiable ⇒ descente de gradient !
ℓCE est convexe mais seulement par rapport à y (pas par rapport à w)
Calcul du gradient
Descente de gradient : W(t+1) = W(t) − η ∂L
∂W
CE
et b(t+1) = b(t) − η ∂L
∂b
CE
∂LCE 1
PN ∂ℓCE
Principal problème : calculer ∂W = N i=1 ∂W
Propriété centrale : chain rule (dérivation des fonctions composées)
∂x ∂x ∂y
=
∂z ∂y ∂z
rétropropagation du gradient de l’erreur par rapport à y en erreur par
rapport à w
Chain rule
∂ℓ y
∂ℓ ∂^
∂x = y ∂x
∂^
∂ℓCE ∂ℓCE ∂ yî ∂si

Régression logistique : ∂W
= ∂ yî ∂si ∂W
Régression logistique : calcul des gradients (1/2)
∂ℓCE ∂ℓCE ∂ yî ∂si

= , ℓCE (ŷi , y∗i ) = −log(ŷc∗ ,i )
∂W ∂ yî ∂si ∂W
Mise à jour pour 1 example :
−1 −1
∂ℓCE
∂ yî
= ŷc∗ ,i
= ^
yi
⊙ δc,c∗ avec δc,c∗ = (0, . . . , |{z}
1 , . . . , 0)
c∗
∂ℓCE
∂si
yi −
=^ y∗i = δiy
∂ℓCE
∂W
= xi T δiy
Régression logistique : calcul des gradients (2/2)
Pour l’ensemble du jeu de données X (N × m), étiquettes Y∗ et prédictions Y

^ (N × K) :
P ^ ∂S
LCE (W, b) = − N1 Ni=1 log(ŷc∗ ,i ), ∂L
∂W
CE
= ∂L CE ∂ Y
^ ∂S ∂W
∂Y
∂LCE ^ − Y∗ = ∆y
=Y
∂s
∂LCE
∂W
= XT ∆y
Entraînement du modèle
La fonction de coût est calculée sur tout le jeu de données d’entraînement :
1 X
N
L= ℓ (ŷi , y∗i ; w, b)
N i=1
Optimisation par descente de gradient :
∂L (t)
w(t+1) = w(t) − η w
∂w
(t) PN ∂ℓ(ŷi ,y∗i )
La complexité du calcul du gradient ∇w = 1
N i=1 ∂w
w(t) croît linéairement
avec :
la dimensionalité de w (nombre de paramètres du modèle),
N, la taille du jeu de données (nombre d’exemples d’apprentissage).
⇒ coûteux, même pour des modèles de dimensionalité modérée et des jeux de
données de taille moyenne !
Descente de gradient stochastique

PN
(t) ∂ℓ(ŷi ,y∗
i )
Solution : approximation du vrai gradient ∇w = 1
N i=1 ∂w
w(t) sur un
échantillon d’exemples (un batch ou “lot”)
⇒ Stochastic Gradient Descent (SGD)
Version online : mise à jour à partir d’un seul exemple
∂ℓ(ŷi , y∗i ) (t)
∇w(t) ≈ w
∂w
Version par mini-batch : mise à jour sur B << N exemples :
1 X ∂ℓ(ŷi , y∗i ) (t)

B
∇w(t) ≈ w
B i=1 ∂w
(a) Gradient complet (b) SGD (online) (c) SGD (mini-batch)

Avantages et inconvénients
La descente de gradient stochastique produit une approximation du véritable gradient

∇w .
- estimation bruitée, pouvant envoyer une direction incorrecte (pente forte pour un
exemple mais pas pour les autres),
- sensibilité aux outliers pour la version en ligne,
+ mises à jour des poids plus nombreuses car itérations moins coûteuses : ×N mises à
jour (online), × NB mises à jour (mini-batch)
+ à nombre de calculs égal, convergence plus rapide
La SGD est incontournable pour la convergence des modèles profonds sur des jeux de
données massifs.
(a) Gradient complet (b) SGD (online) (c) SGD (mini-batch)

Entraînement du perceptron : rétropropagation
Passer de la régression logistique au perceptron multi-couche implique l’ajout d’une

couche cachée (+ sigmoïde)
Entraînement : apprendre les paramètres Wy et Wh (+ bias) par rétropropagation
P P
∂LCE
∂Wy
= N1 Ni=1 ∂ℓ
∂Wy
CE
et ∂LCE
∂Wh
= N1 N ∂ℓCE
i=1 ∂Wh
La dernière couche est équivalente à une régression logistique.

Couche cachée : ∂ℓCE
∂Wh
= xi T ∂ℓ CE
∂ui
⇒ calcul de ∂ℓCE
∂ui
= δih
Rétropropagation du gradient
yi , y∗i ) = − log(ŷc∗ ,i )
Coût pour un seul exemple : LW (^
∂L
∂vi
= δiy = yî − y∗i et ∂L
∂Wy
= δiy hi T
Pour revenir en arrière : on calcule ∂L
∂ui
= δih
Si on connaît δih ⇒ ∂L
∂Wh
= δih xi T ∼ régression logistique
Rétropropagation dans le perceptron
Le calcul de ∂ℓCE
∂ui
= δih ⇒ s’obtient par chain rule :
∂ℓCE ∂ℓCE ∂vi ∂hi

=
∂ui ∂vi ∂hi ∂ui
ce qui permet d’obtenir :
∂ℓCE T ′ T
= δih = δiy Wy ⊙ σ (hi ) = δiy Wy ⊙ (hi ⊙ (1 − hi ))
∂ui
Rétropropagation dans les réseaux profonds
Perceptron multi-couche : ajout d’encore plus de couches

Rétropropagation ∼ Perceptron : en supposant que l’on connaise ∂L
∂Ul+1
= ∆l+1
∂L
∂Wl+1
= Hl T ∆l+1
T
Calcul de ∂L
∂Ul
= ∆l (= ∆l+1 Wl+1 ⊙ Hl ⊙ (1 − Hl ) pour la sigmoïde)
∂L
∂Wl
= Hl−1 T ∆hl
Optimisation des réseaux profonds 44 / 75
Plan du cours
1 Introduction

La rétropropagation en résumé
Rétropropagation (backpropagation) : solution pour l’entraînement de bout en

bout de tous les paramètres des réseaux profonds
Algorithme clé de l’apprentissage profond !
Historique de la rétropropagation
Dérivation des fonctions composées (Leibniz, 1676)
Optimisation par descente de gradient (Cauchy 1847)
Premières applications de la rétropropagation (programmation dynamique, contrôle
Kelley 1960 ; Bryson et Ho 1969)
Formalisation de la rétropropagation pour les réseaux de neurones (Linnainmaa
1970 ; Werbos 1975)
Application aux réseaux de neurones profonds (Rumelhart, Hinton et Williams
1986 ; Lecun 1988)
Mais y a-t-il des inconvénients à utiliser la rétropropagation ?

Optimisation : politique du pas d’apprentissage

(t)
Mise à jour par descente de gradient : w(t+1) = w(t) − η∇w
Comment choisir le pas d’apprentissage η ?
Politiques d’adaptation du pas d’apprentissage
En général, l’heurisiste consiste à faire décroître η durant l’apprentissage (learning rate
“decay”).
η0
Décroissance inversement proportionnelle à l’itération : ηt = 1+r·t
, r vitesse de
décroissance
Décroissance exponentielle : ηt = η0 · e−λt
t
Décroissance en escalier : ηt = η0 · r tu ...
Décroissance exponentielle (η0 = 0.1, λ = 0.1) Décroissance step (η0 = 0.1, r = 0.5, tu = 10)
Optimisation, généralisation et sur-apprentissage
Apprentissage : minimisation d’une fonction de coût L sur un jeu de données =⇒

risque empirique
Jeu d’apprentissage : ensemble d’échantillons représentatif de la distribution des
données et des étiquettes
Objectif : apprendre une fonction de prédiction avec une erreur faible sur la
distribution (inconnue) des données réelles =⇒ risque espéré
Ltrain = 4, Ltrain = 9 Ltest = 15, Ltest = 13

Optimisation ̸= apprentissage ! =⇒ sur-apprentissage ̸= généralisation
Régularisation
Régularisation
Réduire la capacité du modèle pour réduire l’écart entre performances entraînement/test.
Avec un modèle de suffisamment grande capacité, améliore la généralisation et donc
les performances en test.
Régularisation structurelle : ajout d’une contrainte sur les poids pour les forcer à
suivre un a priori
Lr (w) = L(y; y∗ ; w) + αR(w)

Weight decay : régularisation L2 pour pénaliser les poids de norme élevée :
R(w) = ||w||2
Utilisation courante pour les réseaux de neurones

Justifications théoriques et bornes de généralisation dans le cas des SVM
Autres possibilités pour R(w) : régularisation L1 , Dropout, etc.
Régularisation et hyperparamètres
Hyperparamètres pour les réseaux de neurones :

Hyperparamètres d’optimisation : pas d’apprentissage (et évolution), nombre
d’itérations, régularisation, etc.
Hyperparamètres d’architecture : nombre de couches, nombre de neurones, choix de la
non-linéarité, etc.
Le réglage des hyperparamètres permet d’ajuster la capacité du modèle et
d’améliorer la généralisation :
L’utilisation d’un jeu de validation est cruciale !
Implémentation de la rétropropagation 49 / 75
Plan du cours
1 Introduction

Optimisation des réseaux profonds
Optimisation des réseaux profonds : descente de gradient sur la

fonction de coût L

wt+1 = wt − η∇L wt

Rétropropagation de l’erreur : algorithme pour calculer ∇L wt dans
un réseau de neurones
Expression analytique du gradient par chain rule
mais le calcul du gradient peut être difficile à réaliser efficacement
Deux sources de difficultés

1 Problèmes d’optimisation numérique
2 Différenciation automatique (automatic differenciation)
Problèmes d’optimisation numérique

L’accumulation des approximations (arrondis) pose problème.
Underflow : x ≈ 0 ou x = 0 provoque des comportements différents
Division par 0 ⇒ indéterminé (not a number)
Overflow : grandes valeurs de x > 0 ou x < 0 ⇒ not a number
Exemple : softmax sur x = {x1 , x2 , ..., xK }
exi
s(x)i = ∑K xj
j=1 e
Que se passe-t-il si xi = C pour tout i ?

En théorie, s(x)i = K1 quel que soit i, mais en pratique :
C → −∞, eC → 0, division par 0, not a number ! (underflow)
C → +∞, eC → +∞, not a number ! (overflow)

exi
s(x)i = ∑K xj
j=1 e


exi
s(x)i = ∑K xj
j=1 e


exi
s(x)i = ∑K xj
j=1 e


exi
s(x)i = ∑K xj
j=1 e


exi
s(x)i = ∑K xj
j=1 e

Une solution
Ajouter une stabilisation numérique au dénominateur :
z = x − max(xi ) ⇒ s(z) = s(x)

i
maxi (ezi ) = 1 ⇒ pas d’overflow

maxi (ezi ) = 1 ⇒ pas d’underflow
Cas de l’entropie croisée
exi
s(x)i = ∑K xj
j=1 e
z = x − maxi (xi ) ⇒ s(z) = s(x)

Que se passe-t-il pour le calcul de log [s(z)], par exemple dans l’entropie
croisée ?
s(z) = 0 (underflow) ⇒ log [s(z)] → −∞ : not a number !
Solution : stabiliser le log

" #
X
K
xj
log [s(x)i ] = xi − log e
j=1
À nouveau, on substitue : z = x − maxi (xi )

log [s(z)i ] = log [s(x)i ] ?
⇒ underflow, overflow ?
Calcul des dérivées partielles
Plusieurs méthodes permettent de calculer les dérivées de façon automatique :

Approximation numérique : f′ (x) ≈ f(x+h)∗f(x)
h
(méthode des éléments finis)
⊕ Ne nécessite aucune connaissance sur f
⊖ Approximation, stabilité numérique (underflow/overflow)
⊖ Requiert d’évaluer plusieurs fois f
Dérivation symbolique (∼ Mathematica)
⊖ Expressions qui deviennent rapidement complexes, termes redondants ⇒ faible
efficacité
Différenciation automatique
Alterne entre dérivation symboliques et étapes de simplification
Différenciation symbolique au niveau des opérations élémentaires
Simplification en conservant les résultats numériques intermédiaires
Automatic Differentiation (AD)
Définition d’un graphe de calcul : abstraction pour représenter les séquences

d’opérations à inverser pour rétropropager le gradient
Exemple : 1 : f(x, y, z) = (x + y) ∗ z
∂f
Objectif : calculer les valeurs numériques de , ∂f
∂x ∂y
et ∂f
∂z
Supposons que x = −2, y = 5, z = −4, propagation avant ⇒ q = 3, f = −12
Rétropropagation et graphe de calcul
∂f
∂f
= 1 , rétropropagation pour déterminer ⇒ ∂f
, ∂f
∂q ∂z
f=q⋆z ⇒ ∂f
∂q
= z = −4, ∂f
∂z
= q = 3 , rétropropagation pour ⇒ ∂f
, ∂f
∂x ∂y
q=x+y ⇒ ∂f
∂x
= ∂f ∂q
∂q ∂x
= −4 ⋆ 1 = −4 ∂f
∂y
= ∂f ∂q
∂q ∂y
= −4 ⋆ 1 = −4
Différenciation automatique : forward pass, backward pass

Différenciation automatique dans le graphe de calcul : passe avant (forward) puis
différenciation automatique en passe arrière (backward)
Backward pass : calcul récursif des dérivées de haut en bas
Programmation dynamique : gain d’efficacité important par rapport à la différenciation
Une implémentation différent possible est l’autodifférenciation en passe avant :
∂x
1
∂x
= 1,
2
∂q
∂x
= ∂q
∂x
· ∂x
∂x
= 1,
3
∂f
∂x
= · ∂f
∂q
· ∂x
∂x
= −4
∂q
∂x
En pratique, pour un graphe à N nœuds, il faut N passes avant pour la forward AD,
contre 1 passe avant + 1 passe arrière pour la backward AD (backprop).
Quelles opérations implémenter ?
La différenciation symbolique est implémentée seulement au niveau des opérations

“atomiques” :
Les opérateurs arithmétiques binaires : +, −, ×, /, etc.
Les fonctions “élémentaires” : exp, log, cos, sin, etc.
Les fonctions dont les dérivées sont connues, avec une expression analytique dont le
comportement numérique est stable :
Sigmoïde : σ(x) = 1
1+e−x
=⇒ σ ′ (x) = σ(x) [1 − σ(x)]
x = 1.0 ⇒ σ(x) = 0.73, σ ′ (x) = 0.2
Le graphe de calcul est remplaçable par un seul “bloc”dont l’inverse est σ ′ (x).
Mise en œuvre pour un réseau de neurones
h = f(x, W)
⇒ Backward : stockage des valeurs numériques des gradients ∂h

, ∂h
∂W ∂x
Ressources logicielles pour l’apprentissage profond

Fonctionnalités indispensables :
Construction du graphe de calcul et auto-différenciation (autograd)
Exécution transparente sur CPU ou GPU (pas de programmation bas niveau)
De nombreuses bibliothèques disponibles : MatConvNet (Matlab), Caffe/Caffe2
(C++/Python), Torch (Lua/Python/C++), Theano (Python), TensorFlow
(Python), JAX (Python), MXNet (C++/Java), etc.
Actuellement, les deux principales bibliothèques logicielles sont :
1 TensorFlow/Keras (soutenu par Google)
2 PyTorch (soutenu par Facebook)
Keras : implémentation de la régression logistique
Entrée : xi ∈ Rd , d = 784, étiquette yi à K = 10 classes.

Activations : si = xi W + b
PK
Sortie (softmax) : yˆk = esk /( k′ =1 e sk ′ )
1
PN ∗
Fonction de coût : entropie croisée = N i=1 ℓCE (ŷi , yi )
Nombre de paramètres : 784 × 10 + 10 = 7850
from tensorflow import keras

from keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
# Pré-traitement et normalisation
X_train, X_test = X_train.reshape(-1, 784), X_test.reshape(-1, 784)
X_train, X_test = X_train / 255., X_test / 255.
# Encodage one_hot des vecteurs de classe
Y_train, Y_test = keras.utils.to_categorical(y_train, 10), keras.utils.to_categorical(y_test, 10)

PK
1
PN ∗

# Instancie un modèle vide

from tensorflow.keras import Sequential
model = Sequential()
# Ajoute les couches au modèle
from tensorflow.keras.layers import Dense, Activation
model.add(Dense(10, input_dim=784, name='fc1'))

PK
1
PN ∗

# Instancie un modèle vide

from tensorflow.keras import Sequential
model = Sequential()
# Ajoute les couches au modèle
from tensorflow.keras.layers import Dense, Activation
model.add(Dense(10, input_dim=784, name='fc1'))
Keras : apprentissage/inférence
Visualisation d’un résumé du modèle :
model.summary()
Entraînement des paramètres sur le jeu de données d’apprentissage :
# Apprentissage, méthode .fit() "à la scikit-learn"

model.fit(X_train, y_train,batch_size=128, epochs=20,verbose=1)
Keras : évaluation du modèle

Évaluation des performances sur le jeu de test :
scores = model.evaluate(X_test, Y_test, verbose=0)

print("%s TEST: %.2f%%" % (model.metrics_names[0], scores[0]*100))
print("%s TEST: %.2f%%" % (model.metrics_names[1], scores[1]*100))
=⇒ mise en pratique dans la séance de travaux pratiques “Deep Learning avec Keras”
Activations, régularisations, initialisations 62 / 75
Plan du cours
1 Introduction

Non-linéarités modernes
Activations non-linéaires classiques : sigmoïde, tanh
1 ez − e−z
σ(z) = tanh(z) =
1 + e−z ez − e−z
⊖ Régime de saturation =⇒ dérivée nulle hors de x ≈ 0

⇒ Gradient “évanescent”(vanishing gradient) : rétropropagation limitée
⇒ Convergence lente car la mise à jour des paramètres est de faible amplitude
Rectified Linear Unit (ReLU) Nair et Hinton 2010
{
z si z ≥ 0
ReLU(z) = = max {0, z}
0 sinon
Rectified Linear Unit (ReLU)

Réduire l’occurrence des gradients évanescents permet :
⇒ d’entraîner des modèles plus profonds (la décroissance de la norme du gradient est plus
lente),
⇒ d’accélérer la convergence du modèle.
Exemple : CNN à 4 couches entraîné sur CIFAR-10. Remplacer tanh par ReLU permet de
converger en 6× moins d’itérations. Extrait de Krizhevsky, Sutskever et Hinton 2012
Panel de fonctions d’activation
ReLU
Sigmoïde Tanh
Pas de saturation
Saturation Saturation Efficace à calculer
Calcul coûteux Calcul coûteux Non centrée sur zéro
Non centrée sur zéro Centrée sur zéro Les activations négatives sont
ignorées
Fonctions d’activation non-linéaire paramétriques
Deux observations concernant la fonction d’activation ReLU :

1 Pour z < 0, l’activation ReLU vaut 0 avec un gradient nul =⇒ pas de gradient
propagé.
2 Peut-on déterminer automatiquement certains paramètres de la fonction d’activation
(pente, seuil, etc.)?
Leaky ReLU (LReLU) : pente négative λ hyperparamètre à régler

Parametric ReLU (PReLU) : pente négative λk apprise pendant l’entraînement
Randomized ReLU (RReLU) : pente négative λnk tirée selon une loi uniforme
Exponential Linear Unit (ELU) : paramètre de lissage λ hyperparamètre à régler
Initialisation des poids
Comment initialiser les paramètres du modèle ?

La fonction objectif à minimiser non-convexe par rapport aux paramètres des modèles
profonds =⇒ l’initialisation des poids est importante !
Zero-init : toutes les connexions à zéro =⇒ tous les neurones ont la même sortie,
et donc le même gradient !
Initialisation aléatoire faible, par exemple W ∼ U (−0.1, +0.1) ou W ∼ N (0, σ i )
Initialisation “Glorot” :
Pour une entrée x de dimension m et une sortie s, on a : Var[s] = m Var[w] Var[x]
Idée : initialiser les poids par W ∼ √1m N (0, σ i ) Glorot et Bengio 2010
Exemples d’initialisation
Histogramme d’activations
Perceptron multi-couche : 10 couches, 500 neurones par couche.

Activation : tanh
Initialisation : w ∼ N (0, σ i )
=⇒ dans le cas σ i faible, les activations sont toutes proches de 0, mauvaise initialisation.

Activation : tanh
Initialisation : w ∼ N (0, σ i )
=⇒ dans le cas σ i grand, les activations sont toutes saturées (±1), mauvaise
initialisation (gradient évanescent).

Activation : tanh
Initialisation : “Glorot”, W ∼ √ 1 N (0, 1)
500
=⇒ variance adaptative et contrôlée pour chaque couche.

Activation : ReLU
Dans le cas ReLU : Var[s] = 2m Var[w] Var[x] =⇒ W ∼ √1
2m
N (0, σ i )
Initialisation : “Glorot”, W ∼ √ 1
1000
N (0, 1)
=⇒ variance adaptative et contrôlée pour chaque couche.
Régularisation : Dropout Srivastava et al. 2014
Supprime aléatoirement un neurone caché avec une probabilité p, par exemple p = 21 .

Méthode de régularisation pour limiter le sur-apprentissage
Éviter la co-adaptation
Forcer la redondance entre les poids
Interprétation alternative : combinaison de nombreux réseaux de neurones qui
diffèrent légèrement
Dropout : implémentation
Optimisation : le dropout est différentiable
Les activations des neurones dropped sont mises à zéro
Les mises à jour de ces neurones sont ignorées
À l’inférence, plusieurs possibilités :
Appliquer le dropout en inférence et moyenner sur les prédictions de sortie
Alternative plus rapide : inférence normale mais multiplier par p toutes les activations
Équivalent à la moyenne géométrique pour un perceptron
Approximation assez bonne pour un perceptron multi-couche
Bibliographie I
Bryson, Arthur E. et Yu-Chi Ho (1969). Applied Optimal Control : Optimization,

Estimation, and Control. A Blaisdell Book in the Pure and Applied Sciences.
Waltham, Mass : Blaisdell Pub. Co. 481 p.
Cauchy, Augustin Louis (juill. 1847). Comptes rendus hebdomadaires des séances
de l’Académie des sciences. Paris : Gauthier-Villars. url :
http://gallica.bnf.fr/ark:/12148/bpt6k2982c.
Cireşan, Dan C., Ueli Meier et Jürgen Schmidhuber (2012). “Multi-Column
Deep Neural Networks for Image Classification”. In : Proceedings of the IEEE
Conference on Computer Vision and Pattern Recognition (CVPR). Washington, DC,
United States, p. 3642-3649. isbn : 978-1-4673-1226-4. url :
http://dl.acm.org/citation.cfm?id=2354409.2354694.
Cybenko, George (1er déc. 1989). “Approximation by Superpositions of a Sigmoidal
Function”. In : Mathematics of Control, Signals and Systems 2.4, p. 303-314. issn :
0932-4194, 1435-568X. doi : 10.1007/BF02551274. url :
https://link.springer.com/article/10.1007/BF02551274.
Bibliographie II
Fukushima, Kunihiko (1er avr. 1980). “Neocognitron : A Self-Organizing Neural

Network Model for a Mechanism of Pattern Recognition Unaffected by Shift in
Position”. In : Biological Cybernetics 36.4, p. 193-202. issn : 0340-1200, 1432-0770.
doi : 10.1007/BF00344251. url :
https://link.springer.com/article/10.1007/BF00344251.
Glorot, Xavier et Yoshua Bengio (31 mars 2010). “Understanding the Difficulty
of Training Deep Feedforward Neural Networks”. In : Proceedings of the Thirteenth
International Conference on Artificial Intelligence and Statistics. Proceedings of the
Thirteenth International Conference on Artificial Intelligence and Statistics,
p. 249-256. url : http://proceedings.mlr.press/v9/glorot10a.html (visité le
13/04/2018).
Hornik, Kurt (1er jan. 1991). “Approximation Capabilities of Multilayer
Feedforward Networks”. In : Neural Networks 4.2, p. 251-257. issn : 0893-6080. doi :
10.1016/0893-6080(91)90009-T. url :
http://www.sciencedirect.com/science/article/pii/089360809190009T.
Kelley, Henry J. (oct. 1960). “Gradient Theory of Optimal Flight Paths”. In : ARS
Journal 30.10, p. 947-954. doi : 10.2514/8.5282. url :
https://arc.aiaa.org/doi/10.2514/8.5282 (visité le 07/04/2023).
Bibliographie III
Krizhevsky, Alex, Ilya Sutskever et Geoffrey E. Hinton (2012). “ImageNet

Classification with Deep Convolutional Neural Networks”. In : Proceedings of the
Neural Information Processing Systems (NIPS). NeurIPS, p. 1097-1105. url :
http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-
convolutional-neural-networks.pdf.
Lecun, Yann (1988). “A Theoretical Framework for Back-Propagation”. In :
Proceedings of the 1988 Connectionist Models Summer School, CMU, Pittsburg, PA.
Sous la dir. de D. Touretzky, G. Hinton et T. Sejnowski, p. 21-28.
LeCun, Yann et al. (déc. 1989). “Backpropagation Applied to Handwritten Zip
Code Recognition”. In : Neural Computation 1.4, p. 541-551. issn : 0899-7667. doi :
10.1162/neco.1989.1.4.541.
Linnainmaa, Seppo (1970). “The representation of the cumulative rounding error
of an algorithm as a Taylor expansion of the local rounding errors”. Helsinki University.
McCulloch, Warren S. et Walter H. Pitts (1943). “A Logical Calculus of the
Ideas Immanent in Nervous Activity”. In : Bulletin of Mathematical Biophysics 5,
p. 115-133. url : http://www.cse.chalmers.se/~coquand/AUTOMATA/mcp.pdf.
Nair, Vinod et Geoffrey E. Hinton (2010). “Rectified Linear Units Improve
Restricted Boltzmann Machines”. In : Proceedings of the 27th International
Conference on Machine Learning (ICML-10), p. 807-814.
Bibliographie IV
Rosenblatt, Frank (1957). The Perceptron : A Probabilistic Model for Information

Storage and Organization In The Brain.
Rumelhart, D. E., G. E. Hinton et R. J. Williams (1986). “Learning Internal
Representations by Error Propagation”. In : sous la dir. de David E. Rumelhart,
James L. McClelland et
given-i=CORPORATE family=PDP Research Group given=CORPORATE.
Cambridge, MA, USA : MIT Press, p. 318-362. isbn : 978-0-262-68053-0. url :
http://dl.acm.org/citation.cfm?id=104279.104293 (visité le 13/04/2018).
Srivastava, Nitish et al. (2014). “Dropout : A Simple Way to Prevent Neural
Networks from Overfitting”. In : Journal of Machine Learning Research 15,
p. 1929-1958. url : http://jmlr.org/papers/v15/srivastava14a.html (visité le
19/01/2016).
Werbos, Paul John (1975). “Beyond Regression : New Tools for Prediction and
Analysis in the Behavioral Sciences”. Harvard University. 906 p. Google Books :
z81XmgEACAAJ.

Cours Deep 1

Transféré par

Droits d'auteur :

Formats disponibles

Cours Deep 1

Transféré par

Informations du document

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

Cours Deep 1

Transféré par

Droits d'auteur :

Formats disponibles

Apprentissage statistique : modélisation

décisionnelle et apprentissage profond

2 Réseaux de neurones artificiels

4 Optimisation des réseaux profonds

6 Activations, régularisations, initialisations

Accès à de vastes quantités de données non-structurées : images, vidéos, sons,

BBC : 2,4m vidéos Facebook : 350M images 100m caméras de surveillance

Besoin d’accéder à ces données, de les indexer, de les classer : reconnaissance

Extraire du sens des signaux bas niveau

Problème : combler l’écart entre le signal et la sémantique.

Ce que l’humain perçoit

⇒ Comment concevoir de “bonnes”représentations des données ?

Apprentissage statistique classique

Apprentissage statistique classique

Historique des réseaux de neurones

1943 : Neurone artificiel McCulloch et Pitts 1943

1 Réseaux de neurones artificiels

2 Réseaux de neurones artificiels

4 Optimisation des réseaux profonds

6 Activations, régularisations, initialisations

Modèle simplifié d’un neurone réel (1943)

Hyperplan en dimension 2 : droite Hyperplan en dimension 3 : plan

Fonction d’activation non-linéaire

Fonction identité : ϕ(x) = x

Lien avec les neurones biologiques

Neurone formel, activation Heaviside H : ŷ = H(w⊤ x + b)

Équation du neurone artificiel : ŷ = ϕ(w⊤ x + b)

a ↑ : se rapproche de l’échelon de Heaviside (a → ∞)

Application à la classification binaire

Chaque entrée x appartient soit à la classe 0, soit à la classe 1.

En 2D (m = 2), x = {x1 , x2 } ∈ [−5; 5]2

En 2D (m = 2), x = {x1 , x2 } ∈ [−5; 5]2

En 2D (m = 2), x = {x1 , x2 } ∈ [−5; 5]2

En 2D (m = 2), x = {x1 , x2 } ∈ [−5; 5]2

Du neurone formel au réseau de neurones

Du neurone formel au réseau de neurones

Perceptron et classification multi-classe

Perceptron et classification multi-classe

Entrée x ∈ Rm (1 × m), sortie ŷ : concaténation de k neurones

Application à la classification multi-classe

⇒ on appelle ce modèle la régression logistique.

Exemple jouet en 2D pour trois classes

x = {x1 , x2 } ∈ [−5; 5] × [−5; 5], ŷ ∈ {0, 1, 2} (3 classes)

Exemple jouet en 2D pour trois classes

x = {x1 , x2 } ∈ [−5; 5] × [−5; 5], ŷ ∈ {0, 1, 2} (3 classes)

⇒ constat pessimiste : le perceptron échoue sur un problème en apparence très simple…

Au-delà des frontières linéaires

Couche cachée h : projection de

Théorème d’approximation universelle

max∥f(x) − f̂(x)∥ < ϵ

si ϕ est une fonction d’activation non-polynomiale.

Démontré pour les fonctions d’activation sigmoïde en 1989 Cybenko 1989

Théorème d’approximation universelle

max∥f(x) − f̂(x)∥ < ϵ

si ϕ est une fonction d’activation non-polynomiale.

Démontré pour les fonctions d’activation sigmoïde en 1989 Cybenko 1989

Réseaux de neurones profonds

⇒ comment trouver les paramètres du modèle (poids des connexions) ? → apprentissage

2 Réseaux de neurones artificiels

4 Optimisation des réseaux profonds

1 X ∂ℓ(ŷi , y∗i ) (t)