Apprentissage supervisé

Etienne Birmelé

Automne 2020
2
Table des matières

1 Introduction 5
1.1 Apprentissage supervisé . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Critères de qualité d’une règle de prédiction . . . . . . . . . . . . 7
1.3 Sur-apprentissage et ensemble test . . . . . . . . . . . . . . . . . 8
1.4 Validation croisée . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 Cas particulier d’une prédiction binaire : critères de qualité et
courbes ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6 Selection vs Prediction et cas de la grande dimension . . . . . . . 17

2 Méthodes d’arbres 19
2.1 Arbres de décision/classification/régression . . . . . . . . . . . . 19
2.2 Forêts aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3 Modèles linéaires pénalisés 25

3.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2 Regression pénalisée . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.3 Approches pénalisées pour la classification . . . . . . . . . . . . . 31

4 Modèles basées sur les distances 35

4.1 Méthode des 𝑘 plus proches voisins . . . . . . . . . . . . . . . . . 35
4.2 Méthodes SVM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5 Réseaux de neurones feed-forward et apprentissage profond 45

5.1 Réseaux de neurones : modélisation . . . . . . . . . . . . . . . . . 45
5.2 Optimisation du réseau . . . . . . . . . . . . . . . . . . . . . . . 50
5.3 Régularisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6 SuperLearner : un exemple d’Ensembl Learning 59

6.1 Le package Superlearner . . . . . . . . . . . . . . . . . . . . . . . 59
6.2 Un exemple d’utilisation . . . . . . . . . . . . . . . . . . . . . . . 60

7 TP 1 : Manipulation de données et validation croisée 67

7.1 Manipulation de données . . . . . . . . . . . . . . . . . . . . . . . 67
7.2 Apprentissage pour prédire le taux d’ozone . . . . . . . . . . . . 68

3
4 TABLE DES MATIÈRES

8 TP2 - Méthodes d’arbres 69

8.1 CART . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
8.2 Forêts aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

9 TP3 - Modèles linéaires pénalisés 71

9.1 Avec glmnet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
9.2 Avec caret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

10 TP4 - SVM 73
10.1 Avec le package e1071 . . . . . . . . . . . . . . . . . . . . . . . . 73
10.2 Avec caret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

11 TP5 - Réseaux de neurones 75

11.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
11.2 Exercice 2 - Symétries du réseau . . . . . . . . . . . . . . . . . . 76
11.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

12 TP 1 : Manipulation de données et validation croisée - Corrigé 79

12.1 Manipulation de données . . . . . . . . . . . . . . . . . . . . . . . 79
12.2 Apprentissage pour prédire le taux d’ozone . . . . . . . . . . . . 81

13 TP2 - Méthodes d’arbres - Corrigé 85

13.1 CART . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
13.2 Forêts aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

14 TP3 - Modèles linéaires pénalisés - Corrigé 93

14.1 Avec glmnet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
14.2 Avec caret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

15 TP4 - SVM - Corrigé 105

15.1 Avec le package e1071 . . . . . . . . . . . . . . . . . . . . . . . . 105
15.2 Avec caret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

16 TP5 - Réseaux de neurones - Corrigé 119

16.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
16.2 Exercice 2 - Symétries du réseau . . . . . . . . . . . . . . . . . . 120
16.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

17 TP6 - Réseaux de neurones - Classification et Keras 133

17.1 Exercice 1- Classification à 2 classes . . . . . . . . . . . . . . . . 133
17.2 Classification à 3 classes . . . . . . . . . . . . . . . . . . . . . . . 137
Chapitre 1

Introduction

Le but de se chapitre est d’introduire le vocabulaire et les notions de bases de

l’apprentissage supervisé. Les différents algorithmes étant introduits plus tard,
les règles appliquées ici sont souvent simplistes. Les notions introduites resteront
cependant les mêmes avec les algorithmes plus complexes.

1.1 Apprentissage supervisé

On parle d’apprentissage statistique (statistical learning) dans deux cadres dif-

férents :
— Apprentissage supervisé : Dans ce type de problème, on cherche à
définir une règle de prédiction 𝑅 ∶ 𝒳 → 𝒴 d’un variable à prédire 𝑌 en
fonction de variables prédictives 𝑋.
On dispose pour cela de données pour lesquelles à la fois 𝑋 et 𝑌 sont observés
et on cherche, parmi une famille de règles possibles, celle qui optimise un critère
de qualité à définir. Le but est ensuite de pouvoir appliquer ℛ à de nouvelles
données pour lesquelles seules 𝑋 est connu afin d’en déduire une prédiction
𝑌𝑝𝑟𝑒𝑑 = 𝑅(𝑋) de 𝑌 .
— Apprentissage non supervisé : Dans ce second type de problème,
on dispose de variables observées 𝑋 dont on souhaite apprendre une
caractéristique structurelle. Le but n’est alors pas de prédire une autre
variable 𝑌 mais une caractéristique inconnue de la matrice 𝑋. La famille
la plus couramment utilisée d’algorithmes d’apprentissage supervisé est
celle des algorithmes de classification (clustering) dont le but est de créer
des groupes d’individus rassemblés sur la base de la proximité de leurs
valeurs de 𝑋.

5
6 CHAPITRE 1. INTRODUCTION

Exemples : - un diagnostic médical est une règle d’apprentissage supervisé (𝑋

sont les symptômes, 𝑌 le diagnostic)

— la publicité ciblée relève de l’apprentissage supervisé (𝑋 est l’ensemble

des pages visitées, 𝑌 la pertinence d’une proposition de publicité).
— l’estimation d’un modèle linéaire peut être vu comme un problème d’ap-
prentissage supervisé.
— créer des sous-ensembles de patients souffant d’un cancer donné en fonc-
tion de leurs expressions génomiques est un problème d’apprentissage
supervisé.
— l’algorithme EM peut être vu comme un algorithme d’apprentissage non
supervisé où la structure à apprendre est la variable cachée.

Dans la suite de ce cours, nous nous restreignons au problème de

l’apprentissage supervisé (supervised learning).

Si nécessaire, la variable 𝑌 sera complétée par un indice indiquant son type :

𝑌 𝑝𝑟𝑒𝑑 pour une prédiction, 𝑌 𝑜𝑏𝑠 pour sa vraie valeur quand elle est observable,
𝑌 𝑣𝑟𝑎𝑖 pour sa vraie valeur en général.

1.1.1 Exemple jouet

On considère un jeu de données (simulées) de patients souffrant de douleurs

rénales et dont on sait s’ils sont ou non atteints de pyelonéphrite. On recueille
pour chacun d’eux leur sexe, leur IMC, leur température corporelle et leur taux
de CRP (indicateur sanguin). Le but est de déterminer si on peut, à partir de
ces quatre variables, établir une règle de diagnostic fiable d’une infection rénale.

## # A tibble: 200 x 5
## sex BMI temperature CRP infected
## <chr> <dbl> <dbl> <int> <dbl>
## 1 M 26.6 37.2 11 0
## 2 M 19.5 37.9 9 0
## 3 F 27.4 37.3 5 0
## 4 M 19.1 36.4 8 0
## 5 F 21.3 36.5 13 0
## 6 F 24.3 37.0 8 0
## 7 M 23.2 37.5 13 0
## 8 M 31.7 37.0 11 0
## 9 F 19.8 37.4 11 0
## 10 F 25.8 38.0 10 0
## # ... with 190 more rows

Remarque : Le jeu ayant été simulé pour les besoins de l’exemple, la règle
finalement générée ne sera pas forcément pertinente. En réalité, la règle utilisée
est Température > 38.5 et CRP>12
1.2. CRITÈRES DE QUALITÉ D’UNE RÈGLE DE PRÉDICTION 7

1.2 Critères de qualité d’une règle de prédiction

Une procédure d’apprentissage supervisé nécessite de spécifier

a. Un ensemble ℛ de règles candidates

b. Un critère de qualité 𝑓 qu’on cherche à optimiser

Pour un critère de qualité qu’on cherche à minimiser, on définit alors

𝑅 = argmin𝑓(𝑅(𝑋), 𝑌 )
𝑅∈ℛ

L’ensemble des observations (𝑋, 𝑌 ) prises en compte pour réaliser cette minimi-
sation est l’ensemble d’apprentissage.
Exemple : Un critère utilisé très fréquemment et quelle que soit le type de
la variable à prédire 𝑌 est l’erreur quadratique moyenne. Pour un ensemble
d’apprentissage de taille

1 𝑛
𝑓(𝑌 𝑝𝑟𝑒𝑑 , 𝑌 𝑜𝑏𝑠 ) = ∑(𝑌 𝑝𝑟𝑒𝑑 − 𝑌𝑖𝑜𝑏𝑠 )2 ∝ ‖𝑌𝑖𝑝𝑟𝑒𝑑 − 𝑌𝑖𝑜𝑏𝑠 ‖2
𝑛 𝑖=1 𝑖

1.2.1 Exemple jouet

1. On peut choisir par exemple de prendre pour ℛ l’ensemble des règles

de régression logistique incluant tout ou partie des quatre observations.
𝑌 𝑝𝑟𝑒𝑑 ∈ [0, 1] est alors un prédiction de la probabilité qu’il y ait une infec-
tion et le critère à minimiser peut être choisi comme ‖𝑌𝑖𝑝𝑟𝑒𝑑 − 𝑌𝑖𝑜𝑏𝑠 ‖2 . On
retrouve alors la problématique de l’estimation d’un régression logistique
et du choix de modèle (quelles variables choisir).
2. On peut également choisir de prendre pour ℛ un ensemble de règles
binaires organisées en un arbre de décision, ce qui correspond plus à la
pratique médicale.

𝑇 ≤ 𝑠1 𝑇 > 𝑠1

𝐶𝑅𝑃 > 𝑠2 𝐶𝑅𝑃 ≤ 𝑠 𝐼𝑀 𝐶 ≤ 𝑠3 𝐼𝑀 𝐶 > 𝑠3

2

𝑌 =1 𝑌 =0 𝑌 =1

𝐶𝑅𝑃 ≤ 𝑠4 𝐶𝑅𝑃 > 𝑠4

𝑌 =0 𝑌 =1
8 CHAPITRE 1. INTRODUCTION

Dans ce cas, (𝑌 𝑝𝑟𝑒𝑑 − 𝑌 𝑜𝑏𝑠 )2 vaut 0 quand on prend la bonne décision, 1 sinon,
et l’écart quadratique moyen est simplement le taux de mal classés. La question
qui se pose ici est comment parcourir intelligemment tout ou partie de l’espace
des règles possibles pour déterminer la meilleure.

1.3 Sur-apprentissage et ensemble test

Considérons l’exemple jouet avec comme règles possibles les régressions linéaires.
Tout modèle à une, deux ou trois variables peut s’écrire comme un modèle à
quatre variables en imposant certains coefficients nuls. Par conséquent, si on note
ℛ4 l’ensemble des modèles prenant en compte les 4 variables, on a forcément

𝑅 = argmin‖𝑅(𝑋) − 𝑌 ‖2 = argmin‖𝑅(𝑋) − 𝑌 ‖2
𝑅∈ℛ 𝑅∈ℛ4

L’estimation d’un modèle logistique ne donnant jamais de coefficient exactement

nul, le modèle choisi impliquera donc toutes les variables considérées, même si
elles ne sont pas pertinentes.

De manière générale, si on fixe comme but d’obtenir la meilleure prédiction

possible sur l’ensemble d’apprentissage, avec un nombre croissant de variables
disponibles, des variables vont finir par être recrutées car elles améliorent le
critère sur cet ensemble, mais sans aucune pertinence en termes de généralisation.
On parla alors de sur-apprentissage.
Afin d’avoir une estimation plus fiable du pouvour de prédiction de la règle
choisie, le jeu de données observé doit toujours être séparés en deux parties :
— l’ensemble d’apprentissage (learning set) sur lequel la règle est apprise en
minimisant le critère choisi
— l’ensemble test (test set) sur lequel la qualité de la règle est évalué. Il est
primordial de faire cette évaluation sur des individus qui n’ont
pas servis à établir la règle.
Exemple : On considère l’ensemble jouet et l’apprentissage d’une règle basée
sur la régression logistique pour des modèles de taille croissante prenant en
compte dans l’ordre la température, la variable CRP, le sexe et l’IMC.
#Separation en jeu d'apprentissage + jeu test
learningset <- rbinom(dim(toydata)[1],1,.667)
learningdata <- toydata %>% filter(learningset==1)
testdata <- toydata %>% filter(learningset==0)

#Apprentissage des cinq modèles (de 0 à 4 variables prises en compte) et calcul des err
model2 <- glm(infected~temperature+CRP,family=binomial(link="logit"),data=learningdata)
1.4. VALIDATION CROISÉE 9

learningpredict <- predict(model2,type="response")

testpredict <- predict(model2,newdata=testdata,type="response")
learningerror <- mean((learningpredict-learningdata$infected)^2)
testerror <- mean((testpredict-testdata$infected)^2)

On détermine les erreurs moyennes pour chacun des modèles et chacun des
jeux de données (apprentissage et test). Leurs évolutions quand on augmente la
dimension du modèles illustrent le phénomène de sur-apprentissage. Ici, à partir
de la troisième variable, on s’améliore sur le jeu d’apprentissage mais on perd
en potentiel de prédiction en général : il faut donc s’arrêter au modèle à deux
variables.

learning test

0.24

0.22

0.20
error

0.18

0.16

0.14
0 1 2 3 4 0 1 2 3 4
k

1.4 Validation croisée

Suuposons que plusieurs règles apprises aient besoin d’être comparées. Cela
peut par exemple être le cas lorsque la famille de règle considérée dépend d’un
paramètre qu’on ne peut pas (ou ne veut pas) règler via un maximum de vrai-
semblance.

Exemple : Reprenons l’exemple jouet et supposons qu’on cherche à établir une

règle à base d’un arbre de décision de type
10 CHAPITRE 1. INTRODUCTION

𝑇 ≤ 𝑠1 𝑇 > 𝑠1

𝐼𝑀 𝐶 ≤ 𝑠2 𝐼𝑀 𝐶 > 𝑠 𝐶𝑅𝑃 ≤ 𝑠3 𝐶𝑅𝑃 > 𝑠3

2

𝑌 =1 𝑌 =0 𝑌 =1

𝐶𝑅𝑃 ≤ 𝑠4 𝐶𝑅𝑃 > 𝑠4

𝑌 =0 𝑌 =1

Il faut alors décider des valeurs des différentes constantes. On peut de plus
vouloir comparer d’autres modèles issus d’architectures d’arbres différentes, ou
de stratégies de modélisation différentes (régression logistique par exemple).

La stratégie consistant à comparer tous les modèles candidats sur le jeu test
n’est pas valide car le jeu test sert alors à déterminer la règle, et ne peut plus
servir d’étalon pour estimer le pouvoir de généralisation.

Il faudrait donc reséparer le jeu d’apprentissage en jeu d’apprentissage + jeu de

comparaison. Cela oblige cependant à rediminuer le jeu d’apprentissage, ce qui
n’est pas forcément souhaitable si celui-ci n’est pas très grand.

Une manière communénemt utilisé pour éviter de réduire l’ensemble d’apprentis-

sage est appelée validation croisée. Son but est, pour toutes les règles à comparer,
de déterminer une prédiction pour tout individu de l’ensemble d’apprentissage,
tout en respectant la règle disant qu’il ne faut pas prédire sur les individus qui
ont servis à apprendre.

Pour ce faire, on sépare aléatoirement l’ensemble d’apprentissage en 𝐾 en-

sembles, appelés plis (folds) et on réalise la boucle suivante :

— pour chaque fold 𝐹𝑖 , on apprend la règle sur tous les individus ne faisant
pas partie de 𝐹𝑖 , et on réalise une prédiction pour les individus de 𝐹𝑖

On obtient ainsi une prédiction pour chaque individu de l’ensemble d’appren-

tissage et on peut alors déterminer le critère de qualité pour chaque règle et
sélectionner ainsi la meilleure.

Exemple : Dans le cas de l’exemple jouet et des modèles logistiques emboîtés

du paragraphe précédent, le choix du nombre de variables à garder peut typique-
ment se faire par validation croisée sur le jeu d’apprentissage, le jeu test servant
uniquement à évaluer la capacité de généralisation de la méthode finalement
sélectionnée.

Etape 1 : segmentation du jeu de données

1.4. VALIDATION CROISÉE 11

#Separation en jeu d'apprentissage + jeu test

learningset <- rbinom(dim(toydata)[1],1,.667)
learningdata <- toydata %>% filter(learningset==1)
testdata <- toydata %>% filter(learningset==0)

#Separation du jeu d'apprentissage en 10 folds

#crétion d'un vecteur qui contient les chiffres de 1 à 10 à parts égales (plus ou moins 1)
nfold <- 10
foldsize <- floor(dim(learningdata)[1]/nfold)
folds <- c(rep(c(1:nfold),foldsize)) #remplit avec 1,..,nfold autant de fois que possible
remaining <- dim(learningdata)[1]-length(folds)
if (remaining>0){ #remplit si besoin le reste du vecteur en repartant de 1
folds <- c(folds,c(1:remaining))
}
#affectation des individus dans les folds et ajout de l'information à learningdata
learningdata <- learningdata %>% add_column(fold = sample(folds))

Etape 2 : Pour tout pli 𝐹𝑖 , les modèles sont appris sur tous les individus du jeu
d’apprentissage n’appartenant pas à 𝐹𝑖 , puis l’erreur de prédiction est évaluée
sur les individus de 𝐹𝑖 .
learningerrors <- tibble(k0=rep(NA,dim(learningdata)[1]),k1=k0,k2=k0,k3=k0,k4=k0) #contient les e

for (i in 1:nfold){

ldata <- learningdata %>% filter(fold!=i) #new learningdata: all folds but i
tdata <- learningdata %>% filter(fold==i) #new test data: fold i

learningerrors$k0[learningdata$fold==i] <- (mean(ldata$infected)-tdata$infected)^2

model1 <- glm(infected~temperature,family=binomial(link="logit"),data=ldata)

tpredict <- predict(model1,newdata=tdata,type="response")
learningerrors$k1[learningdata$fold==i] <- (tpredict-tdata$infected)^2

model2 <- glm(infected~temperature+CRP,family=binomial(link="logit"),data=ldata)

tpredict <- predict(model2,newdata=tdata,type="response")
learningerrors$k2[learningdata$fold==i] <- (tpredict-tdata$infected)^2

model3 <- glm(infected~temperature+CRP+sex,family=binomial(link="logit"),data=ldata)

tpredict <- predict(model3,newdata=tdata,type="response")
learningerrors$k3[learningdata$fold==i] <- (tpredict-tdata$infected)^2

model4 <- glm(infected~temperature+CRP+sex+BMI,family=binomial(link="logit"),data=ldata)

tpredict <- predict(model4,newdata=tdata,type="response")
learningerrors$k4[learningdata$fold==i] <- (tpredict-tdata$infected)^2
12 CHAPITRE 1. INTRODUCTION

meanerror <- learningerrors %>% summarise_all(mean)

Les erreurs moyennes en fonction du nombre de variables sont les suivantes

## # A tibble: 1 x 5
## k0 k1 k2 k3 k4
## <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 0.241 0.186 0.159 0.164 0.166

On décide donc de garder le modèle à deux variables

Etape 3 : On apprnde le modèle à deux variables sur l’ensemble de l’ensemble

d’apprentissage et on évalue la méthode sur le jeu test
model2 <- glm(infected~temperature+CRP,family=binomial(link="logit"),data=learningdata)
testpredict <- predict(model2,newdata=testdata,type="response")
mean((testpredict-testdata$infected)^2)

## [1] 0.1522159

Remarques :

— La version particulière de la validation croisée dans laquelle on crée au-

tant de folds que d’individus dans l’échantillon est appelée Leave-one-out
(LOO ou LOOV). Cela revient, pour chaque individu, à faire une prédic-
tion suivant la règle apprise sur l’ensemble des autrs individus.
— Dans de nombreuses méthodes d’apprentissage disponibles sous forme de
fonctions, en particulier sous R, la validation croisée n’a pas besoin d’être
implémentée car déjà intégrée à la fonction (cf aides des fonctions).

1.5 Cas particulier d’une prédiction binaire : cri-

tères de qualité et courbes ROC

1.5.1 Critères de qualité

Dans le cas d’une variable 𝑌 ∈ {0, 1}, d’autres critères sont couramment utilisés.
Par analogie avec le problème médical, on parle d’individu positif quand 𝑌 = 1
et d’individu négatif quand 𝑌 = 0.

Plus précisément, pour une règle de décision donnée, chaque individu appartient
à l’une des quatre catégories suivantes
1.5. CAS PARTICULIER D’UNE PRÉDICTION BINAIRE : CRITÈRES DE QUALITÉ ET COURBES ROC13

𝑌 𝑝𝑟𝑒𝑑 = 0 𝑌 𝑝𝑟𝑒𝑑 = 1
𝑣𝑟𝑎𝑖
𝑌 =0 Vrai négatif (𝑇 𝑁 ) Faux positif (𝐹 𝑃 )
𝑌 𝑣𝑟𝑎𝑖 = 1 Faux négatif (𝐹 𝑁 ) Vrai positif (𝑇 𝑃 )

Remarque : Par la suite, 𝑇 𝑁 , 𝐹 𝑃 , 𝐹 𝑁 et 𝑇 𝑃 seront utilisés pour désigner

les comptages de chaque catégorie quand la règle est appliquée sur un jeu de
données pour lequel 𝑌 est observé (𝑌 𝑣𝑟𝑎𝑖 = 𝑌 𝑜𝑏𝑠 dans ce cas).
Des critères de qualité différents sont alors utilisés, qui sont très populaires car
facilement interprétables par les experts métiers (médecins par exemple).
+Accuracy
𝑇 𝑃 +𝑇 𝑁
proportion de bien classés : 𝑇 𝑃 +𝐹 𝑃 +𝑇 𝑁+𝐹 𝑁

+Sensitivity ou Rappel (Recall) ou True positive rate

𝑇𝑃
proportion de vrais positifs bien classés : 𝑇 𝑃 +𝐹 𝑁

+Specificity ou True negative rate

𝑇𝑁
proportion de vrais négatifs bien classés : 𝑇 𝑁+𝐹 𝑃

+False positive rate

𝐹𝑃
proportion de vrais positifs parmi les négatifs : 𝑇 𝑁+𝐹 𝑃

+Precision.
𝑇𝑃
proportion des vrais positifs parmi les positifs 𝑇 𝑃 +𝐹 𝑃

Exemple : Prenons le jeu jouet et appliquons le critère médical qui consiste à

considérer comme souffrant d’une infection tout patient qui a une température
d’au moins 38.5°𝐶 et un taux de 𝐶𝑅𝑃 d’au moins 12.
## # A tibble: 4 x 2
## type counts
## <chr> <int>
## 1 TP 31
## 2 FP 2
## 3 TN 118
## 4 FN 49
Sur ce jeu de données, la spécificité de cette règle est faible :
TP/(TP+FN)

## [1] 0.3875
Moins de la moitié des vraies infections sont détectées.
Par contre, la sensitivité est bonne :
14 CHAPITRE 1. INTRODUCTION

TN/(TN+FP)

## [1] 0.9833333

Moins de 5% des gens ne souffrant pas d’une infection seront traités à tort.

Remarques : 1. Il est souvent plus pertinent d’un point de vue mathématique,

même lorsque 𝑌 𝑜𝑏𝑠 ∈ {0, 1}, de prédire 𝑌 𝑝𝑟𝑒𝑑 ∈ [0, 1]. En d’autres termes, éta-
blir une règle qui ne prédit pas si un individu est positif ou négatif, mais prédit
sa probabilité d’être positif. On peut dans ce cas revenir à un critère de type er-
reur quadratique moyenne. Il est à noter cependant que les problèmes pratiques
requièrent parfois une réponse dure, c’est-à-dire purement binaire (ex : décider
si oui ou non on doit prendre des antibiotiques).

2. le critère Accuracy peut être trompeur dans le cas d’un faible nombre de
positifs dans la population. Prenons le cas d’un maladie touchant 1 des
individus. Déclarer tout le monde sain donne alors un score de 99 de bien
classés, ce qui est excellent mais totalement inutile !
3. les autres critères doivent être pris par paires : si on veut simplement
éviter les faux positifs, il suffit de déclarer tout le monde négatif, et
inversement. On cherche donc généralement à maximiser conjointement
la spécificité et la sensitivité, ou la précision et le rappel (cf courbes ROC
et PR plus bas).

1.5.2 Courbes de comparaison de méthodes

Ces indicateurs sont une alternative pour comparer des méthodes différentes sur
des jeux de données quand la variable d’intérêt est binaire, et que les différentes
méthodes comportent des paramètres qu’il faut régler.

[Link] Courbe ROC

Considérons une méthode de classification en deux classes, qui dépend d’un para-
mètre. La courbe ROC est une courbe obtenu en traçant la courbe paramétrique
du True positive rate en fonction du False positive rate.

Par exemple, si on cherche à ne classer les données de l’étude jouet en ne prenant

en compte que la température, c’est-à-dire en déclarant infectés tous les patients
ayant une température supérieure à un certain seuil, on obtient la courbe sui-
vante :
1.5. CAS PARTICULIER D’UNE PRÉDICTION BINAIRE : CRITÈRES DE QUALITÉ ET COURBES ROC15

1.00 35.9
37
37.4
37.8
38.2
0.75
true_positive_fraction

38.4

38.8
0.50
39.3

0.25 39.7

0.00 Inf

0.00 0.25 0.50 0.75 1.00

false_positive_fraction

On y voit que si on choisit une telle règle avec une limite de 38.5, on aura
plus de 60% des infections qui seront détectées mais près de 30% des patients
non-infectés qui seront déclarés positifs.

L’idéal serait évidemment d’avoir une valeur du paramètre qui ne fasse aucune
erreur, ce qui correspondrait à une courbe passant par le coin supérieur gauche
du cadran.

En pratique, les courbes ROC sont en fait surtout utilisées pour comparer des
méthodes entre elles.

Considérons le jeu de données jouet et supposons qu’on cherche à comparer les

trois méthodes suivantes :

1. Règle de type 1 : On déclare positif toute personne ayant suffisamment

de fièvre. Le paramètre à régler est alors la température seuil.

2. Règle de type 2 : On déclare positif toute personne ayant plus de 38.5 de

fièvre et un taux minimum de CRP, à régler.

3. Règle de type 3 : On réalise une régression logistique et on déclare positif

tout individu tel que P(𝑌 = 1|𝑋) est supérieure à un seuil, à régler.
16 CHAPITRE 1. INTRODUCTION

1.00

0.75

type
crp
0.50
y

logistic
temp

0.25

0.00

0.00 0.25 0.50 0.75 1.00

x

Dans ce cas, on voit que la fonction logistique a une courbe ROC plus haute
que les autres, et s’approchant plus du point optimal. La conclusion est que le
modèle logistique est sans doute préférable ici, avec un seuil à fixer de façon à
choisir un des points de la courbe proche du point optimal.

Interprétation : L’aire sous la courbe ROC, appelée AUC (Area Under the
Curve) est parfois utilisée comme critère de qualité d’une méthode de classifica-
tion. Considérons le vecteur des individus classés suivant 𝑌 𝑝𝑟𝑒𝑑 . L’AUC corres-
pond alors à la probabilité, quand on tire un vrai positif et un vrai négatif au
hasard, que le premier soit bien avant le second dans le classement.

[Link] Courbe Precision-Recall

Une alternative à la courbe ROC est la courbe Precision-Recall. Elle est moins
utilisée mais constitue une meilleure solution dans le cas des variables mal équi-
librées, c’est-à-dire avec une faible proportion d’individus tels que 𝑌 = 1.

Dans ce cas, les courbes vont toutes du coin en haut à gauche vers celui en bas
à droite, et une courbe est d’autant meilleure qu’elle se rapproche du point en
haut à droite.
1.6. SELECTION VS PREDICTION ET CAS DE LA GRANDE DIMENSION17

1.00

0.75

type
crp
0.50
y

logistic
temp

0.25

0.00

0.00 0.25 0.50 0.75 1.00

x

1.6 Selection vs Prediction et cas de la grande

dimension
Les chapitres suivants de ce cours vont aborder différentes familles d’algorithmes
permettant de réaliser de l’apprentissage supervisé à travers les angles suivants :

1. description du principe de leur fonctionnement

2. avantages et inconvénients en termes de prédiction et de sélection, qui
sont deux objectifs assez différents dans les problèmes d’apprentissage
supervisé. La prédiction consiste à avoir la meilleure prédiction 𝑅(𝑋)
possible, la sélection consiste à déterminer les variables importantes pour
déterminer 𝑌 .
3. comportement dans le cas de jeux de grande dimension (le nombre de
variables est plus grand que le nombre d’observations). Ce type de jeu
se retrouve dans de nombreuses applications, notamment en génomique,
mais est à différencier des jeux type Big Data où au contraire les obser-
vations sont très nombreuses.
18 CHAPITRE 1. INTRODUCTION
Chapitre 2

Méthodes d’arbres

2.1 Arbres de décision/classification/régression

Un arbre de décision (𝑌 binaire), de classification (𝑌 discret) ou de régression

(𝑌 continu) est un outil de classification particulièrement aisé à utiliser une fois
appris et qui a l’avantage d’être relativement simple à interpréter quand il n’est
pas trop grand.

Une observation 𝑋 part de la racinde de l’arbre et suit les embranchements en

fonction de la variable concernée à chaque étape jusqu’à aboutir dans une feuille,
dont l’étiquette indique la décision prise.

𝑇 ≤ 𝑠1 𝑇 > 𝑠1

𝐶𝑅𝑃 > 𝑠2 𝐶𝑅𝑃 ≤ 𝑠 𝐼𝑀 𝐶 ≤ 𝑠3 𝐼𝑀 𝐶 > 𝑠3

2

𝑌 =1 𝑌 =0 𝑌 =1

𝐶𝑅𝑃 ≤ 𝑠4 𝐶𝑅𝑃 > 𝑠4

𝑌 =0 𝑌 =1

La difficulté réside bien entendu dans l’apprentissage de cet arbre. L’algorithme

le plus couramment utilisé est l’algorithme CART (Classification and Regres-
sion Tree) (Breiman et al., 1984).

19
20 CHAPITRE 2. MÉTHODES D’ARBRES

2.1.1 Construction d’un premier arbre par séparation ité-

rative des noeuds

On considère un ensemble 𝒮1 de valeurs (𝑋𝑖 , 𝑌𝑖 ) d’observations issues du jeu

d’apprentissage. Le principe de construction de l’arbre est simple, à savoir que
chaque feuille est séparée en deux si elle n’est pas assez pure et de façon à obtenir
deux filles les plus pures possibles. Une fois l’arbre construit, chaque feuille se
voit attibuer l’étiquette de la classe majoritaire dans le cas de la classification,
la moyenne des observations dans le cas de la régression.

Pour appliquer ce principe, un indice d’impureté 𝐼(𝑆) pour un noeud de valeurs

𝑆 et un critère de séparation sont définis.

— Classification : indice d’impureté de Gini : On note (𝑝1 , … , 𝑝𝐾 ) la

proportion de chaque valeur de 𝑌 dans 𝑆

𝐼𝐺𝑖𝑛𝑖 (𝑆) = ∑ 𝑝𝑘 (1 − 𝑝𝑘 )
𝑘

Cet indice est un indice d’impureté, dans la mesure où il d’autant plus petit
que l’une des classes est largement majoritaire dans l’ensemble (on montre sans
mal qu’il est nul si l’ensemble est pur et maximal si toutes les classes sont
équireprésentées).

— Classification : indice d’impureté de l’entropie :

𝐼𝐸𝑛𝑡𝑟𝑜𝑝𝑦 (𝑆) = − ∑ 𝑝𝑘 log 𝑝𝑘

𝑘

Cet indice s’interprète de la même manière que l’indice de Gini.

— Régression : indice d’impureté de la variance :

𝐼(𝑆) = 𝑣𝑎𝑟(𝑌 (𝑆))

où 𝑌 (𝑆) désigne l’échantillon des valeurs de 𝑌 sur l’ensemble 𝑆. Plus ce critère

est petit, plus les valeurs de 𝑌 dans ce noeud sont regroupées autour de 𝑌 (𝑆)
et donc plus le noeud est pur.

— Critère de séparation
L’algorithme parcourt l’ensemble des variables possibles et l’ensemble
(discrétisé) de leurs valeurs possibles, et choisit le couple (Variable,Seuil)
qui sépare 𝑆 en (𝑆1 , 𝑆2 ), de tailles 𝑛1 et 𝑛2 de façon à maximiser
2.2. FORÊTS ALÉATOIRES 21

𝑛1 𝑛2
𝐼(𝑆) − 𝐼(𝑆1 ) − 𝐼(𝑆2 ) dans le cas de la classification
𝑛1 + 𝑛 2 𝑛1 + 𝑛 2
𝑣𝑎𝑟(𝑌 (𝑆)) − 𝑣𝑎𝑟(𝑌 (𝑆1 )) − 𝑣𝑎𝑟(𝑌 (𝑆2 )) dans le cas continu

— Alternative Une alternative à la notion d’impureté, utilisée notamment

pour la régressions, est de revenir au critère de qualité de l’apprentissage,
typiquement ‖𝑌 𝑝𝑟𝑒𝑑 − 𝑌 𝑜𝑏𝑠 ‖2 . Le couple (𝑉 𝑎𝑟𝑖𝑎𝑏𝑙𝑒, 𝑆𝑒𝑢𝑖𝑙) choisi est alors
celui qui permet la plus forte diminution de ce critère.

2.1.2 Elagage

Les opérations précédentes peuvent être répétées si besoin jusqu’à n’obtenir que
des noeuds purs, c’est-à-dire tels que 𝐼(𝑆) = 0 sur toutes les feuilles. On risque
cependant alors de se retrouver en situation de sur-apprentissage.
Plusieurs manières d’éviter cela ont été développées, divisées en deux familles :
— early stopping ou pre-pruning : le but est d’arrêter la construction de
l’arbre avant qu’il devienne trop grand. On peut pour cela fixer un seuil
non nul pour le critère d’impureté.
Le package rpart propose par exemple cette approche avec un seuil (le
paramètre cp) fixé par validation croisée.
— post-pruning : on construit l’arbre total puis on ressupprime les branches
n’apportant pas d’amélioration du critère visé. L’approche early-stopping
est cependant préférée en général.

2.2 Forêts aléatoires

Si l’arbre de décision a un avantage indéniable qui est sa lisibilité, il a l’inconvé-
nient d’être difficile à élaguer et d’être sujet à instabilité en cas de nombreuses
variables candidates et/ou de variables explicatives corrélées : un jeu très légè-
rement différent peut mener à un arbre très dissemblable.
Les forêts aléatoires ont été introduites pour pallier à ce désavantage (Breiman,
2001). Elles font partie de la famille des méthodes de Bagging c’est-à-dire des mé-
thodes reposant sur la prise en compte de plusieurs prédicteurs afin de dégager
une majorité.

2.2.1 Principe

Le principe est très simple, à savoir qu’une forêt aléatoire est un ensemble
d’arbres de décision/classification/régression donnant chacun une prédiction. La
prédiction finale est obtenue
22 CHAPITRE 2. MÉTHODES D’ARBRES

— en prenant la classe la plus représentée dans le cadre décision/classification

— en moyennant les prédictions dans le cadre de la régression
Afin que les arbres de la forêt soient différents les uns des autres, de l’aléa est
introduit à deux niveaux :

1. bootstrap des individus : chaque arbre est appris non pas sur toutes
les données du jeu d’apprentissage mais sur un échantillon bootstrap de
celui-ci
2. sous-échantillonnage des variables : A chaque séparation de noeud,
toutes les 𝑝 variables ne sont pas prises en compte, mais seulement un
√
sous-échantillon aléatoire de 𝑓(𝑝) d’entre elles. En pratique, 𝑓(𝑝) = 𝑝
est souvent utilisé, mais 𝑓(𝑝) paut aussi être considéré comme un para-
mètre à régler.

Cette approche permet de régler le problème du sur-apprentissage en apprenant

un grand nombre d’arbres peu profonds (donc sans doute pas assez précis indi-
viduellement), mais dont on espère qu’ils prendront majoritairement la bonne
décision.

2.2.2 Erreur out-of-bag

Les différents paramètres (choix du nombre de variables échantillonnées, pro-

fondeur des arbres, …) peuvent être réglés par validation croisée. Cependant, il
peuvent également l’être sans être obligé de reséparer le jeu d’apprentissage en
sous-jeu.
En effet, pour un échantillon de taille 𝑛 assez grand, chaque individu n’est
pas dans l’échantillon bootstrap avec probabilité (1 − 𝑛1 )𝑛 ≈ 1𝑒 ≈ 0.36. Plus
d’un tiers des arbres construits n’utilisent donc pas l’observation 𝑥𝑖 dans leur
apprentissage (on dit que 𝑖 est out-of-bag) et peuvent être utilisés pour estimer
l’erreur faite sur 𝑥𝑖 .
On peut donc remplacer l’estimation par cross-validation de l’erreur sur l’indi-
vidu 𝑖 par (𝑦𝑖𝑝𝑟𝑒𝑑 − 𝑦𝑖𝑜𝑏𝑠 )2 où (𝑦𝑖𝑝𝑟𝑒𝑑 ) est la prédiction faite par l’ensemble des
arbres tels que 𝑖 est out-of-bag (en prenant la classe majoritaire ou la moyenne
suivant le type de prédiction).

2.2.3 Importance des variables

Une mesure de l’importance des variables a également été proposée dans le cadre
des forêts aléatoires.
Considérons une variable d’intérêt V. Pour chaque arbre de la forêt, on peut
considérer l’ensemble 𝒜 des individus out-of-bag. En permutant les valeurs de
𝑉 parmi les individus de 𝒜, on obtient un jeu de données dans lequel 𝑉 n’a
2.2. FORÊTS ALÉATOIRES 23

aucun pouvoir prédictif. On peut alors mesurer l’importance de la variable en

comparant le pouvoir prédictif avant et après la permutation.
— En considérant la perte du pourcentage de bien classés (accuracy) suite
à la permutation.
— En considérant le rapport entre l’erreur quadratique après et avant la
permutation.
Plus ces indices sont grands, plus la variables est importante dans cet arbre.
En les moyennant sur l’ensemble de la forêt, on obtient un indice global d’im-
portance des variables, qui permet de comparer les pouvoirs prédictifs de ces
dernières.

2.2.4 Conclusion

Les forêts aléatoires sont un net gain par rapport à un arbre seul en termes de
stabilité, permettent la sélection de variables grâce à la mesure d’importance et
offrent souvent un meilleur contrôle du sur-apprentissage et donc une meilleure
prédiction. Tout cela se fait cependant au détriment de l’interprétabilité de la
méthode.
24 CHAPITRE 2. MÉTHODES D’ARBRES
Chapitre 3

Modèles linéaires pénalisés

3.1 Contexte
Le problème de la régression, équivalent au modèle linéaire gaussien, s’écrit
comme

Trouver 𝛽 𝑅 = 𝑎𝑟𝑔𝑚𝑖𝑛‖𝑌 − 𝑋𝛽‖22

𝛽

et peut naturellement être utilisé dans le cadre de l’apprentissage pour une

variable 𝑌 continue qu’on estime raisonnable de modéliser par une loi normale.
PLusieurs difficultés sont cependant à noter dans ce cas :

1. Dans le cas de variables explicatives corrélées, l’interprétation de leurs

coefficients est difficile. En effet, une variable peut ‘attirer’ l’influence
d’une autre variable qui lui est fortement corrélée.

Par exemple, sous un vrai modèle gaussien 𝑌 = 𝑋1 + 𝑋2 + 𝜖 avec 𝑋1 ≈ 𝑋2 , les

modèles de paramètres 𝛽 = (1, 1), 𝛽 = (2, 0) ou 𝛽 = (3, −1) auront des vraisem-
blances très proches et le mauvais modèle peut potentiellement être sélectionné.

2. Quel que soit le nombre de variables ayant réellement une influence non
nulle sur 𝑌 , tous les coefficients de 𝛽 sont non-nuls. Il y a donc risque
de sur-apprentissage. De plus, dans le cas de la grande dimension (plus
de variables explicatives potentielles que d’observations), l’estimateur du
maximum de vraisemblance 𝛽 = (𝑋 ′ 𝑋)−1 𝑋 ′ 𝑌 n’est pas défini.
3. Suite au point précédent, il est important de procéder à de la sélection
de variables en choisissant le variables à garder.
4.

25
26 CHAPITRE 3. MODÈLES LINÉAIRES PÉNALISÉS

3.2 Regression pénalisée

Le principe des régressions pénalisées est de pénaliser le critère à optimiser afin

de favoriser les modèles ayant une caractéristique recherchée permettant de gérer
soit la corrélation entre variables, soit la sélection de ces dernières.

3.2.1 Régression Ridge

La première possibilité pour effectuer une régression pénalisée est d’utiliser une
pénalité de type Ridge. L’idée est de forcer le vecteur de coefficients 𝛽 à être
borné en norme 𝐿2 . Intuitivement, les problèmes de colinéarité sont alors réglés
par le fait qu’une variable ne peut ‘attirer’ les coefficients des variables qui lui
sont corrélées que dans une certaine mesure.
knitr::include_graphics('fig/[Link]')
3.2. REGRESSION PÉNALISÉE 27
28 CHAPITRE 3. MODÈLES LINÉAIRES PÉNALISÉS

Considérons, pour 𝑐 > 0 fixé, le problème

Trouver 𝛽 𝑅𝑖𝑑𝑔𝑒 = 𝑎𝑟𝑔𝑚𝑖𝑛‖𝑌 − 𝑋𝛽‖22 sous la contrainte ‖𝛽‖22 ≤ 𝑐

𝛽

La méthode des multiplicateurs de Lagrange dit qu’il existe 𝜆 ≥ 0 tel que la

solution du problème satisfait les conditions de Karush Kuhn Tucker à savoir
que

1. Le gradient de ‖𝑌 − 𝑋𝛽‖22 + 𝜆(‖𝛽‖2 − 𝑐) est nul

2. 𝜆(‖𝛽‖2 − 𝑐) = 0

Une manière d’approcher le problème ci-dessous est donc de considérer, pour

un coefficient 𝜆 > 0 donnée, le problème suivant :

Trouver 𝛽 𝑅𝑖𝑑𝑔𝑒 (𝜆) = 𝑎𝑟𝑔𝑚𝑖𝑛‖𝑌 − 𝑋𝛽‖22 + 𝜆‖𝛽‖22

𝛽

On notera que pour 𝜆 tendant vers 0, on retrouve la régression classique, alors

que pour 𝜆 infini, la solution est 𝛽 = 0. En faisant varier 𝜆, on obtient ainsi une
famille de modèles de plus en plus pénalisés.
Proposition 1. La solution du problème est donnée par

𝛽 𝑅𝑖𝑑𝑔𝑒 = (𝑋 ′ 𝑋 + 𝜆I𝑝 )−1 𝑋 ′ 𝑌

Démonstration. Soit 𝑓(𝛽) = ‖𝑌 − 𝑋𝛽‖22 + 𝜆‖𝛽‖22 .

𝜕𝑓
= −2𝑋 ′ (𝑌 − 𝑋𝛽) + 2𝜆𝛽
𝜕𝛽

En annulant cette dérivée, (𝑋 ′ 𝑋 + 𝜆I𝑝 )−1 𝑋𝑌 est un point stationnaire. De plus,

𝜕2𝑓
= 2(𝑋 ′ 𝑋 + 𝜆I𝑝 )
𝜕𝛽 2

qui est définie positive, si bien qu’il s’agit d’un minimum local.
De plus, la fonction 𝑓(𝛽) est strictement convexe comme somme d’une fonc-
tion convexe et d’une fonction strictement convexe. Le minimum local est donc
unique et global.

Remarques :

1. On constate que la pénalité rend le problème strictement convexe, et

donc résoluble par une descente de gradient quelque soit la dimension.
3.2. REGRESSION PÉNALISÉE 29

2. Dans les cas de petite dimension, l’estimateur ridge est un estimateur

biaisé, contrairement à l’estimateur des moindes carrés. Par contre, il est
de moindre variance.
3. En cas de variables corrélées, la répartition entre les variables est
meilleure : l’estimateur des moindres carrés risque de mettre tout le
poids sur une variable, ce qui n’est pas le cas de l’estimateur ridge.

Une question importante laissé est celle du choix de la valeur de 𝜆 à appliquer.

Une approche visuelle du comportement consiste à faire varier 𝜆 d’une valeur
assez grande vers 0. Le moment où les chemins partent de 0 et leur écartement
de 0 donnent une idée de l’importance des variables.

Un choix automatique de 𝜆 peut être fait essentiellement suivant deux approches

concurrentes :

1. Validation croisée
2. Stability selection : dans le cas de la grande dimension, on effectue un
grand nombre d’apprentissage sur des sous-échantillonages (80% des don-
nées par exemple) et on garde les variables appraissant dans plus de la
moitié des échantillons. On peut ensuite réaliser un apprentissage en pe-
tite dimension sur les variables sélectionnées.

3.2.2 LASSO

En grande dimension, la régression Ridge rend le problème bien posé mais le

résultat difficile à interpréter. En effet, potentiellement toutes les variables sont
explicatives.

Un autre type de pénalisation consiste à favoriser les solutions ayant un grand

nombre de coordonnées nulles, en considérant la norme 1 plutôt que la norme
2 du vecteur 𝛽. Cette norme aura en effet pour conséquence de mettre de nom-
breux coefficients exactement à 0. On parle alors de régression parcimonieuse.

Trouver 𝛽 𝐿𝑎𝑠𝑠𝑜 = 𝑎𝑟𝑔𝑚𝑖𝑛‖𝑌 − 𝑋𝛽‖22 sous la contrainte ‖𝛽‖1 ≤ 𝑐

𝛽

D’un point de vue géométrique, la forme des boules de la norme 1 va faire que
de les solutions auront de nombreux coefficients nuls en grande dimension.
knitr::include_graphics('fig/[Link]')
30 CHAPITRE 3. MODÈLES LINÉAIRES PÉNALISÉS

A nouveau, le lagrangien de la fonction à optimiser permet de définir un nouveau

problème d’optimisation, à savoir, pour un coefficient 𝜆 > 0 :

Trouver 𝛽 𝐿𝑎𝑠𝑠𝑜 = 𝑎𝑟𝑔𝑚𝑖𝑛‖𝑌 − 𝑋𝛽‖22 + 𝜆‖𝛽‖1

𝛽

Il n’est plus possible de déterminer la solution à l’aide d’une formule close.

Cependant, la fonction est convexe et admet donc un unique minimum qu’il est
possible de trouver de façon algorithmique (algorithme LARS par exemple).
Le choix de 𝜆 se fait suivant les mêmes critères que dans le cas de la régression
Ridge.

3.2.3 Elastic-Net et Group-Lasso

L’inconvénient de la régression parcimonieuse est qu’en cas de variables corré-

lées, une variable va être privilégiée par rapport aux autres, contrairement à la
régression Ridge.
Il existe plusieurs types de compromis possibles entre les avantages des pénalités
ridge et Lasso.

1. Elastic-Net : Cette approche consiste à introduire une pénalité Ridge et

une pénalité Lasso afin de profiter des avantages des deux pénalités. Le
prix à payer est celui de la détermination d’un nouveau paramètre 𝛼
servant à régler le poids respectifs des deux pénalités

Trouver 𝛽 𝐸−𝑁𝑒𝑡 = 𝑎𝑟𝑔𝑚𝑖𝑛‖𝑌 − 𝑋𝛽‖22 + 𝜆(𝛼‖𝛽‖21 + (1 − 𝛼)‖𝛽‖22 )

𝛽
3.3. APPROCHES PÉNALISÉES POUR LA CLASSIFICATION 31

2. Group-Lasso : Dans certaines applications, on connaît à l’avance une

partition des variables en groupes corrélées 𝐺1 , … , 𝐺𝑞 . On note 𝛽𝑞 le sous-
vecteur de 𝛽 correspondant aux variables dans le groupe 𝑞. L’approche
Group-Lasso consiste à appliquer une pénalité Ridge à l’intérieur de ces
groupes, afin de limiter les effets des corrélations, tout en appliquant une
pénalité Lasso entre les groupes, afin que la plupart des groupes se voient
attribuer un vecteur 𝛽𝑞 nul.

𝑞
𝐺𝐿
Trouver 𝛽 = 𝑎𝑟𝑔𝑚𝑖𝑛‖𝑌 − 𝑋𝛽‖22 + 𝜆( ∑ ‖𝛽𝑞 ‖22 )
𝛽 𝑖=1

3.3 Approches pénalisées pour la classification

3.3.1 Principe

Les différentes pénalités précédentes peuvent être adaptées à d’autres fonctions

objectifs que ‖𝑌 − 𝑋𝛽‖22 , notamment à l’opposé d’une vraisemblance. On peut
ainsi les appliquer dans le cadre de tout modèle linéaire généralisé

Trouver 𝛽 𝐸−𝑁𝑒𝑡 = 𝑎𝑟𝑔𝑚𝑖𝑛 − 𝑙𝑜𝑔(ℓ(𝑋)) + 𝜆(𝛼‖𝛽‖21 + (1 − 𝛼)‖𝛽‖22 )

𝛽

où ℓ(𝑋) désigne la vraisemblance du modèle.

Par exemple, dans le cas d’une régression logistique, il s’agit de minimiser
𝑛 𝑒𝛽𝑋𝑖 2 2
− ∑𝑖=1 (log( 1+𝑒 𝛽𝑋𝑖 )) + 𝜆(𝛼‖𝛽‖1 + (1 − 𝛼)‖𝛽‖2 )

3.3.2 Exemple

On considère le jeu de données Colon du package plsgenomics, qui contient le

niveau d’expression de 2000 gènes de 62 tissus dont 40 sont tumoraux et 22 sont
sains.
Après avoir séparé les données en jeu d’apprentissage et de test, on peut appli-
quer une pénalité ridge et regarder l’évolution des coefficients pour 𝜆 décrois-
sant. On constate, pour la pénalité ridge, un faisceau qui illustre bien la prise
en compte de la colinéarité (les trajectoires se croisent peu quand 𝜆 évolue)
mais une absence de sélection puisque toutes les variables ont dès le départ des
coeeficients non nuls. Pour Lasso, on voit bien les variables “s’allumer” les unes
après les autres, permettant de faire de la sélection, mais les trajectoires croi-
sées rendent les interprétations difficiles. Elastic-Net offre un compromis entre
les deux.
32 CHAPITRE 3. MODÈLES LINÉAIRES PÉNALISÉS

[Link] <- glmnet([Link]$X,[Link]$Y,family="binomial",alpha=0)

[Link] <- glmnet([Link]$X,[Link]$Y,family="binomial",alpha=1)
[Link] <- glmnet([Link]$X,[Link]$Y,family="binomial",alpha=.5)
mfrow=c(1,3)
plot([Link])

2000 2000 2000 2000

4e−04
Coefficients

0e+00
−4e−04

0.00 0.02 0.04 0.06

L1 Norm
plot([Link])

0 12 17 20 23 22 22
0.02
Coefficients

0.01
0.00
−0.01

0.00 0.02 0.04 0.06 0.08 0.10 0.12

L1 Norm
3.3. APPROCHES PÉNALISÉES POUR LA CLASSIFICATION 33

plot([Link])

0 42 59 77 90 97
0.010
0.005
Coefficients

0.000
−0.005

0.00 0.02 0.04 0.06 0.08 0.10

L1 Norm

Pour choisir 𝜆 dans le but de faire de la prédiction, on procède par validation

croisée et on apprend le modèle correspondant.
[Link] <- [Link]([Link]$X,[Link]$Y,nfolds=5)
[Link]$[Link]

## [1] 0.1353255
[Link] <- glmnet([Link]$X,[Link]$Y,family="binomial",alpha=.5,nlambda=1,lam

Finalement, le modèle retenu peut être évalué sur le jeu test

[Link] <- [Link]([Link],[Link]$X,type="response")
predictions_proba <- exp([Link])/(1+exp([Link]))
predictions_hard <- round(predictions_proba)
results <- tibble(proba=predictions_proba,MAP=predictions_hard,truth=[Link]$Y-1)
results

## # A tibble: 18 x 3
## proba[,"s0"] MAP[,"s0"] truth
## <dbl> <dbl> <dbl>
## 1 0.373 0 1
## 2 0.993 1 1
## 3 0.998 1 1
## 4 0.168 0 0
## 5 0.752 1 1
## 6 0.603 1 1
34 CHAPITRE 3. MODÈLES LINÉAIRES PÉNALISÉS

## 7 0.141 0 0
## 8 0.821 1 1
## 9 0.787 1 1
## 10 0.795 1 1
## 11 0.144 0 0
## 12 0.860 1 1
## 13 0.983 1 1
## 14 0.997 1 1
## 15 0.194 0 1
## 16 0.178 0 1
## 17 0.572 1 1
## 18 0.741 1 1
confusionMatrix(data=as_factor(predictions_hard),as_factor([Link]$Y-1))

## Confusion Matrix and Statistics

##
## Reference
## Prediction 0 1
## 0 3 3
## 1 0 12
##
## Accuracy : 0.8333
## 95% CI : (0.5858, 0.9642)
## No Information Rate : 0.8333
## P-Value [Acc > NIR] : 0.6479
##
## Kappa : 0.5714
##
## Mcnemar's Test P-Value : 0.2482
##
## Sensitivity : 1.0000
## Specificity : 0.8000
## Pos Pred Value : 0.5000
## Neg Pred Value : 1.0000
## Prevalence : 0.1667
## Detection Rate : 0.1667
## Detection Prevalence : 0.3333
## Balanced Accuracy : 0.9000
##
## 'Positive' Class : 0
##
Chapitre 4

Modèles basées sur les

distances

Le but de cette section est de d’introduire deux types de classification liées

directement à la géométrie du nuage de points dans la mesure où elles reposent
directement sur la notion de distance.

4.1 Méthode des 𝑘 plus proches voisins

La méthode des 𝑘 plus proches voisins, désignée le plus souvent par kNN pour 𝑘-
Nearest Neighbours est sans doute la méthode d’apprentissage conceptuellement
la plus simple.

Le principe est, pour un point pour lequel une décision est à prendre, de sélec-
tionner les 𝑘 points les plus proches dans le jeu d’apprentissage et de faire une
prédiction

— par vote dans le cas de la classification, la classe majoritaire l’emportant

— par moyenne dans le cas de la régression
pl

35
36 CHAPITRE 4. MODÈLES BASÉES SUR LES DISTANCES

[Link] 3.5

3.0

2.5

2.0

5 6 7
[Link]

Variantes : Il est possible de complexifier cette procédure

— en choisissant une autre distance que la norme euclidienne si elle semble

plus adapté au problème
— en assignant des poids aux votes, à priori décroissants avec la distance

Avantages :

— Simplicité du concept et de sa mise en oeuvre

— Peu de paramètres à régler (𝑘 et le choix de la distance retenue)

Inconvénients :

— Nécessite de garder toutes les données en mémoire pour faire une prédic-
tion (on ne peut pas seulement garder la règle, comme dans le cas d’un
arbre de décision ou d’un modèle linéaire)
— Très sensible au fléau de la dimension : quand le nombre de variables
explicatives (dimension de 𝑋) devient grand, la distance est un outil dont
il faut se méfier. Par exemple, quelques calculs élémentaires montrent
que quand cette dimension devient très grande, des points tirés de façon
équiprobable dans [0, 1]𝑑 sont essentiellement équidistants et tous très
proches du bord !.
4.2. MÉTHODES SVM 37

4.2 Méthodes SVM

On considère un problème de classification à deux classes, avec un ensemble
d’apprentissage {(𝑥𝑖 , 𝑦𝑖 )1≤𝑖≤𝑛 } tel que 𝑦𝑖 ∈ {−1, +1}.
Les méthodes SVM (Support Vector Machine ou Séparateur à Vaste Marge)
reposent sur la définition d’une surface de séparation, c’est-à-dire une fonction
𝑓 ∶ 𝒳 → R tel que 𝑦 = +1 ⇔ 𝑓(𝑥) > 0.

4.2.1 Séparateurs linéaires

Considérons dans un premier temps les fonctions 𝑓 de type linéaires

𝑑
𝑓(𝑥) = ∑ 𝑤𝑗 𝑥𝑗 + 𝑏 =< 𝑤, 𝑥 > +𝑏
𝑗=1

où 𝑑 désigne la dimension des données. Cela correspond à une séparation de

l’espace par un hyperplan défini par < 𝑤, 𝑥 > +𝑏 = 0.

[Link] Données linéairement séparables

Les données d’apprentissage sont linéairement séparables si un tel hyperplan

réalisant une classification parfaite existe

1.5
[Link]

1.0

0.5

2.0 2.5 3.0 3.5 4.0 4.5

[Link]
38 CHAPITRE 4. MODÈLES BASÉES SUR LES DISTANCES

Dans de tels cas, le nombre de séparateurs possibles est alors infinis et il convient
de définir un critère de qualité pour définir le meilleur, qui sera retenu. Le critère
retenu est alors la marge du séparateur, définie par

𝑀 𝑎𝑟𝑔𝑒(𝑓) = min 𝑑(𝑥𝑖 , 𝐻)

𝑖

où 𝑑(𝑥𝑖 , 𝐻) est la distance du 𝑖𝑒 point à l’hyperplan 𝐻.

Intuitivement, le meilleur choix est celui de l’hyperplan qui passe au milieu de
l’espace entre les deux nuages, ce qui correspond à l’hyperplan dont la marge
est la plus grande.
Le problème de définition du séparateur devient donc de déterminer 𝑤∗ et 𝑏∗
tels que

𝑓 ∗ = argmax 𝑀 𝑎𝑟𝑔𝑒(𝑓)

Vecteurs support :
Il est à noter que les éléments les plus proches de l’hyperplan 𝐻 ∗ dans chacune
des deux classes sont à même distance de 𝐻 ∗ (sinon, l’hyperplan pourrait être
légèrement décalé de façon à augmenter sa marge, ce qui contredirait la définition
de 𝑓 ∗ ). Les vecteurs les plus proches de 𝐻 ∗ sont appelés vecteurs supports.

1.5
[Link]

1.0

0.5

2.0 2.5 3.0 3.5 4.0 4.5

[Link]

Dans cet exemple, en admettant que l’hyperplan indiqué est optimal, il y a trois
vecteurs supports (un point bleu et deux points rouges).
4.2. MÉTHODES SVM 39

Il est à noter :

1. ce sont les vecteurs supports qui définissent 𝑓 ∗ au sens où l’ajout de points

supplémentaires dans le jeu de donnée à l’extérieur de la bande définie
pour les points supports ne modifieront pas 𝑓 ∗ .
2. pour tout 𝑥, si on note 𝑝(𝑥) son projeté sur 𝐻 ∗ ,

𝑤 1
𝑑(𝑥, 𝐻) = | < 𝑥 − 𝑝(𝑥), >|= | < 𝑥, 𝑤 > − < 𝑝(𝑥), 𝑤 > |
‖𝑤‖ ‖𝑤‖

Or, comme 𝑝(𝑥) ∈ 𝐻, < 𝑝(𝑥), 𝑤 > +𝑏 = 0 donc

| < 𝑤, 𝑥 > +𝑏|

𝑑(𝑥, 𝐻) =
‖𝑤‖

En particulier, si 𝑥𝑠 est un vecteur support, la marge du séparateur vaut

𝑀 𝑎𝑟𝑔𝑒(𝑓) = |<𝑤,𝑥 𝑠 >+𝑏|
‖𝑤‖ .
3. Multiplier 𝑤 et 𝑏 par une même constante donne exactement la même
séparation et la même marge. On peut donc imposer | < 𝑤, 𝑥𝑠 > +𝑏| = 1
1
et obtenir une marge de ‖𝑤‖

Optimisation :
Le problème s’écrit alors

1
Trouver 𝑤∗ = argmin ‖𝑤‖2 tel que ∀𝑦𝑖 = 1, < 𝑤, 𝑥𝑖 > +𝑏 ≥ 1
2
∀𝑦𝑖 = −1, < 𝑤, 𝑥𝑖 > +𝑏 ≤ −1

En introduisant les multiplicateurs de Lagrange (un 𝛼𝑖 par condition, c’est-à-

dire par vecteur de données), la nouvelle fonction à considérer est

𝑛
1
𝐿(𝑤, 𝑏, 𝛼) = ‖𝑤‖2 − ∑ 𝛼𝑖 [𝑦𝑖 (< 𝑤, 𝑥𝑖 > +𝑏) − 1]
2 𝑖=1

Le problème dual associé est alors

Trouver 𝛼∗ = argmax 𝑄(𝛼) tel que ∀𝑖, 𝛼𝑖 ≥ 0

où
40 CHAPITRE 4. MODÈLES BASÉES SUR LES DISTANCES

𝑄(𝛼) = inf 𝐿(𝑤, 𝑏, 𝛼)

𝑤,𝑏

On rappelle (cf cours d’optimisation sous contraintes ou (Nocedal and Wright,

2006)) que lorsque la fonction à optimiser initialement (ici 21 ‖𝑤‖2 ) et les
contraintes sont convexes, il est équivalent de résoudre les problèmes primal et
dual.
En annulant les dérivées partielles suivant 𝑤 et 𝑏 (à faire en exercice), on obtient
que

𝑛
𝜕𝐿
(𝑤, 𝑏, 𝛼) = 0 ⇒ 𝑤 = ∑ 𝛼𝑖 𝑦𝑖 𝑥𝑖
𝜕𝑤 𝑖=1
𝑛
𝜕𝐿
(𝑤, 𝑏, 𝛼) = 0 ⇒ ∑ 𝛼𝑖 𝑦𝑖 = 0
𝜕𝑏 𝑖=1

En injectant ces résultats dans 𝐿, on obtient

1
𝑄(𝛼) = ‖𝑤‖2 − < 𝑤, 𝑤 > − ∑ 𝛼𝑖 𝑦𝑖 𝑏 + ∑ 𝛼𝑖
2 𝑖 𝑖
𝑛
1
= ∑ 𝛼𝑖 − ∑ 𝛼 𝛼 𝑦 𝑦 < 𝑥 𝑖 , 𝑥𝑗 >
𝑖=1
2 1≤𝑖,𝑗≤𝑛 𝑖 𝑗 𝑖 𝑗

Le problème d’optimisation dual à résoudre pour obtenir 𝛼∗ est alors

𝑛
1
Trouver 𝛼∗ = argmax(∑ 𝛼𝑖 − ∑ 𝛼 𝛼 𝑦 𝑦 < 𝑥𝑖 , 𝑥𝑗 >)
𝛼 𝑖=1
2 1≤𝑖,𝑗≤𝑛 𝑖 𝑗 𝑖 𝑗
𝑛
sous la contrainte 𝛼𝑖 ≥ 0 et ∑ 𝛼𝑖 𝑦𝑖 = 0
𝑖=1

Ce problème peut être résolu à l’aide d’algorithmes d’optimisation quadratique

à contraintes linéaires, et on obtient

1. La valeur de 𝛼∗ . Les valeurs non nulle de ce vecteur donnent l’identité

des vecteurs supports
4.2. MÉTHODES SVM 41

1 𝑛
2. 𝑤∗ par la formule 𝑤∗ = 2 ∑𝑖=1 𝛼∗𝑖 𝑦𝑖 𝑥𝑖
3. 𝑏∗ par la formule 𝑦𝑠 (< 𝑤∗ , 𝑥𝑠 > +𝑏∗ ) = 1 valable pour tout vecteur
support.

Une nouvelle donnée 𝑥 peut dorénavant être classée en déterminant le signe de

𝑓(𝑥) =< 𝑤∗ , 𝑥 > +𝑏∗ .

4.2.2 Données non linéairement séparables

2.5

2.0
[Link]

1.5

1.0

3 4 5 6 7
[Link]
Dans la plupart des cas, les données ne sont pas linéairement séparables, c’est-
à-dire qu’aucun hyperplan ne permet de séparer parfaitement l’ensemble
d’apprentissage.
Dans ce cas, on introduit, pour des valeurs de 𝑤 et de 𝑏 données, une pénalité
pour chaque sommet

𝜉𝑖 = max(0, 1 − 𝑦𝑖 (< 𝑤, 𝑥𝑖 > +𝑏))

Cette pénalité est nulle, pour les points qui sont bien classés, avec une distance
l’hyperplan supérieure à 𝑓𝑟𝑎𝑐1‖𝑤‖ : dans le cas séparable, elle est nulle pour
tout le monde.
Par contre, elle est non nulle pour les points situés dans la bande centrale (dis-
tance à l’hyperplan inférieure à la marge) et les points mal classés.
Le problème considéré est alors
42 CHAPITRE 4. MODÈLES BASÉES SUR LES DISTANCES

𝑛
Trouver 𝑤∗ = argmin‖𝑤‖2 + 𝐶 ∑ 𝜉𝑖 tel que ∀𝑖, 𝜉𝑖 ≥ 0
𝑖=1
∀𝑖, 𝑦𝑖 (< 𝑤, 𝑥𝑖 > +𝑏) ≥ 1 − 𝜉𝑖

Il se résout de la même manière que dans le cas précédent. Il est à noter que le
constante 𝐶 est à choisir et fait office de paramètre de régularisation (plus 𝐶
est petit, plus on impose la séparation).

4.2.3 SVM non linéaires : le Kernel Trick

[Link] Noyaux

Définition :
Théorème 1 (Mercer). Soit 𝒳 un compact dans R𝑑 et 𝐾 ∶ 𝒳 × 𝒳 → R une
fonction symétrique (càd K(x,y)=K(y,x)). On suppose aussi que ∀𝑓 ∈ 𝐿2 (𝒳),
∫𝒳 𝐾(𝑥, 𝑦)𝑓(𝑥)𝑓(𝑦)𝑑𝑥𝑑𝑦 ≥ 0 (condition de Mercer).
Alors il existe un espace de Hilbert ℋ et 𝜙 ∶ 𝒳 → ℋ tel que ∀𝑥, 𝑦 ∈ 𝒳,
𝐾(𝑥, 𝑦) =< 𝜙(𝑥), 𝜙(𝑦) >
La fonction 𝐾(𝑥, 𝑦) s’appelle **noyau** positif défini.
Exemples :
— Noyau linéaire : 𝐾(𝑥, 𝑥′ ) =< 𝑥, 𝑥′ >
′
— Noyau exponentiel : 𝐾(𝑥, 𝑥′ ) = 𝑒−𝛾‖𝑥−𝑥 ‖
′ 2
— Noyau gaussien : 𝐾(𝑥, 𝑥′ ) = 𝑒−𝛾‖𝑥−𝑥 ‖
Interprétation : Le noyau peut être vu comme une mesure de similarité : plus
𝑥 et 𝑥′ sont semblables, plus la valeur du noyau est grande.
Il a de plus l’avantage, via le théorème de Mercer, de représenter le produit sca-
laire dans un espace de dimension plus grande où les nuages seront peut-être plus
faciles à séparer linéairement. Or, les méthodes SVM vues précédemment n’uti-
lisent la structure de l’espace que via les produits scalaires : utiliser un noyau
va donc permettre d’utiliser les méthodes SVM dans l’espace ℋ, en remplaçant
𝑥 par 𝜙(𝑥), et ce sans avoir besoin de déterminer ℋ et 𝜙.

[Link] SVM à noyau

Dans ℋ, le problème SVM s’écrit

𝑛
Trouver 𝑤∗ = argmin‖𝑤‖2 + 𝐶 ∑ 𝜉𝑖 tel que ∀𝑖, 𝜉𝑖 ≥ 0
𝑖=1
∀𝑖, 𝑦𝑖 (< 𝑤, 𝜙(𝑥𝑖 ) > +𝑏) ≥ 1 − 𝜉𝑖
4.2. MÉTHODES SVM 43

dont le problème dual peut s’écrire

𝑛
1
Trouver 𝛼∗ = argmax( ∑ 𝛼𝑖 𝛼𝑗 𝑦𝑖 𝑦𝑗 < 𝜙(𝑥𝑖 ), 𝜙(𝑥𝑗 ) > − ∑ 𝛼𝑖 )
𝛼 2 1≤𝑖,𝑗≤𝑛 𝑖=1
𝑛
sous les contraintes 𝐶 ≥ 𝛼𝑖 ≥ 0 et ∑ 𝛼𝑖 𝑦𝑖 = 0
𝑖=1

ou encore
𝑛
1
Trouver 𝛼∗ = argmax( ∑ 𝛼𝑖 𝛼𝑗 𝑦𝑖 𝑦𝑗 𝐾(𝑥𝑖 , 𝑥𝑗 ) − ∑ 𝛼𝑖 )
𝛼 2 1≤𝑖,𝑗≤𝑛 𝑖=1
𝑛
sous les contraintes 𝐶 ≥ 𝛼𝑖 ≥ 0 et ∑ 𝛼𝑖 𝑦𝑖 = 0
𝑖=1

Ce problème peut être résolu algotihmiquement sans déterminer ℋ et 𝜙. De

plus, on a alors 𝑤∗ = ∑𝑖 𝛼∗𝑖 𝑦𝑖 𝜙(𝑥𝑖 ) et 𝑦𝑠 (< 𝑤∗ , 𝜙(𝑥𝑠 ) > +𝑏∗ ) = 1 pour tout
vecteur support. Par conséquent, un nouveau vecteur 𝑥 est classé via la fonction

𝑓(𝑥) = ∑ 𝛼∗𝑖 𝑦𝑖 𝐾(𝑥𝑖 , 𝑥) + 𝑏∗

𝑖

où 𝑏∗ est tel que, pour tout vecteur support 𝑥𝑠 , 𝑦𝑠 (∑𝑖 𝛼∗ 𝑖𝐾(𝑥𝑖 , 𝑥𝑠 ) + 𝑏∗ ) = 1.

44 CHAPITRE 4. MODÈLES BASÉES SUR LES DISTANCES
Chapitre 5

Réseaux de neurones
feed-forward et
apprentissage profond

Ce chapitre du cours est en majeure partie issu du cours de Julie Delon, merce
à elle de m’avoir permis de l’utiliser.

5.1 Réseaux de neurones : modélisation

Les modèles linéaires de régression ou de classification permettent de faire des
prédiction sous la forme

𝑦 ̂ = 𝑓(𝑤′ 𝑥)

où
— 𝑤 est le vecteur des coefficients du modèle
— x est obtenu en prenant en compte le variables prédictives et en ajoutant
un 1 afin que le coefficient 𝑤0 permette la preise en compte d’un offset ;
— 𝑓 est une fonction de liaison, par exemple l’identité dans le cas des mo-
dèles gaussiens ou la fonction logistique inverse pour le modèle logistique
(éventuellement couplée à un seuillage si on veut une prédiction en 0/1)
L’espace des fonctions candidates parmi lesquelles optimiser est par conséquent
limité : la contrainte 𝑓 −1 (𝑦) est linéaire est en effet très forte.
Le but d’un réseau de neurones est de représenter une fonction 𝑦(𝑥;
̂ 𝑤) plus
générale que dans le modèle linéaire et d’apprendre la valeur du vecteur de

45
46CHAPITRE 5. RÉSEAUX DE NEURONES FEED-FORWARD ET APPRENTISSAGE PROFOND

paramètres 𝑤 permettant une bonne prédiction sur une base d’apprentissage

donnée. On s’intéresse ici aux réseaux feedforward (non-bouclés), pour lesquels
il n’y a pas de connexion retour de la sortie vers l’entrée ou vers les couches
intermédiaires. De tels réseaux sont d’une importance considérable aujourd’hui
dans de nombreuses applications commerciales ou académiques.

5.1.1 Exemple de réseau à deux couches

x1

x2

Commençons par un exemple très simple le réseau feedforward à deux couches

de la figure précédente. Ce réseau a une unique couche intermédiaire, on va
supposer typiquement que ces valeurs s’écrivent :

[1] [1] [1]

𝑎𝑖 = 𝑔(𝑊𝑖1 𝑥1 + 𝑊𝑖2 𝑥2 ), 𝑖 = 1, 2

avec 𝑔 une fonction non linéaire, par exemple la fonction Rectified Linear Unit
ou ReLU

ReLU(𝑥) = 𝑚𝑎𝑥(0, 𝑥)

Le graphe liant les variables intervenants dans ce réseau peut se dessiner ainsi
5.1. RÉSEAUX DE NEURONES : MODÉLISATION 47

Figure 5.1 – La fonction 𝑅𝑒𝐿𝑈 (𝑥) = max(0, 𝑥). Cette fonction est recomman-
dée comme fonction d’activation par défaut dans les réseaux de neurones.

W1 W2

x1 z1 ReLu a1

x2 z2 ReLu a2

On suppose que la sortie 𝑦 est calculée à partir de la couche intermédiaire comme

[2] [1] [2] [1]
𝑦 = 𝑊1 𝑎1 + 𝑊2 𝑎2 .
La fonction complète représentée par ce réseau est donc la suivante :
2 2
[2] [1]
𝑦(𝑥)
̂ = ∑ 𝑊𝑖 𝑔 (∑ 𝑊𝑖𝑘 𝑥𝑘 ) = 𝑊 [2] 𝑚𝑎𝑥(0, 𝑊 [1] 𝑥),
𝑖=1 𝑘=1

[1] [1]
𝑊11 𝑊12
et elle dépend des paramètres 𝑊 [1] = ( [1] [1] ) et 𝑊
[2]
= (𝑊1[2] [2]
𝑊2 ).
𝑊21 𝑊22

Le numéro entre crochets dans la notation 𝑊 [1] désigne la couche sur laquelle
on se trouve.
48CHAPITRE 5. RÉSEAUX DE NEURONES FEED-FORWARD ET APPRENTISSAGE PROFOND

Représenter la fonction binaire XOR (ou exclusif) par un réseau à deux couches
n’est pas très complexe et une solution peut être trouvée intuitivement. Dans
les cas réels, on peut avoir des données massives et de grande dimension, que
l’on cherche à approcher par un réseau profond dépendant de plusieurs millions
de paramètres. Dans ce type de cas, déterminer le bon jeu de paramètres est
donc beaucoup moins évident.

5.1.2 Architecture du réseau et Forward Propagation

Un réseau de neurone de type feedforward enchaîne différentes couches de neu-

rones, chaque couche étant fonction de la précédente. Si le vecteur d’entrée est
𝑥 ∈ R𝑝 , la première couche effectue d’abord une opération linéaire ou affine sur
𝑥, puis calcule une fonction non linéaire du résultat :

𝑧[1] = 𝑊 [1] 𝑥 + 𝑏[1] puis 𝑎[1] = 𝑔[1] (𝑧 [1] ) (5.1)

avec 𝑊 [1] une première matrice de poids de taille 𝑛[2] × 𝑝, 𝑏[1] un vecteur d’offset
de taille 𝑛[2] × 1 et 𝑔[1] une fonction d’activation, généralement non linéaire
(lorsqu’on écrit 𝑔[1] (𝑧) avec 𝑧 un vecteur, cela signifie que 𝑔[1] est appliquée à
toutes les coordonnées de 𝑧).
La 𝑘𝑒𝑚𝑒 couche s’écrit alors en fonction de la précédente comme

𝑎[𝑘] = 𝑔[𝑘] ⏟⏟⏟⏟⏟⏟⏟

(𝑊 [𝑘] 𝑎[𝑘−1] + 𝑏[𝑘] ), (5.2)
𝑧[𝑘]

avec 𝑊 [𝑘] une matrice de poids de taille 𝑛[𝑘+1] × 𝑛[𝑘] , 𝑏[𝑘] un vecteur d’offset de
taille 𝑛[𝑘+1] × 1, et ainsi de suite jusqu’à la couche de sortie 𝑙

̂ 𝑊 ; 𝑏) = 𝑔[𝑙] (𝑊 [𝑙] 𝑎[𝑙−1] + 𝑏[𝑙] ) .

𝑦(𝑥; (5.3)

Fonctions d’activation
Les fonctions 𝑔[𝑘] sont appliquées sur les noeuds intermédiaires du réseau. Elle
permettent au modèle de capturer des non linéarités dans les relations entre les
données. Voici quelques exemples de fonctions d’activation que l’on trouve dans
la littérature
— la fonction tanh et la fonction logistique 𝜎(𝑧) = 1+𝑒1 −𝑧 ont été très long-
temps plébiscitées comme fonctions d’activation pour les réseaux de neu-
rones ; ces deux fonctions présentent le défaut d’avoir une dérivée quasi-
ment nulle dès que 𝑧 s’éloigne trop de 0, on verra que cela peut être un
handicap pour entraîner le réseau ;
5.1. RÉSEAUX DE NEURONES : MODÉLISATION 49

— la fonction 𝑅𝑒𝐿𝑈 (𝑥) = max(𝑥, 0) est aujourd’hui considérée comme la

fonction d’activation standard à la fois dans l’industrie et dans la re-
cherche académique, mais de très nombreux autres choix sont possibles
et fonctionnent bien selon les applications, l’idée étant de garder des fonc-
tions suffisamment simples pour pouvoir optimiser le réseau rapidement ;
— la fonction 𝑅𝑒𝐿𝑈 peut parfois être avantageusement remplacée par une
fonction du type max(𝑥, 0) + 𝜖 min(𝑥, 0) avec 𝜖 petit ;
— La fonction valeur absolue |𝑥| est utilisée lorsque l’on souhaite modé-
liser une invariance par changement de signe (comme par exemple en
reconnaissance d’objets, pour approcher une invariance en fonction des
conditions d’illumination).

Forward Propagation.
Le processus consistant à évaluer la fonction 𝑦(𝑥;
̂ 𝑊 ; 𝑏) dans un réseau feedfor-
ward est appelé Forward Propagation, puisqu’il consiste à propager l’information
de gauche à droite dans le réseau. C’est ce processus qui permet à un réseau de
neurones de faire des prédictions à partir de données.

Justification biologique.
On parle de réseaux de neurones car ces réseaux sont en partie inspirés par les
neurosciences, chaque noeud du réseau jouant un rôle ‘analogue’ à celui d’un
neurone dans le cerveau. Si de nombreux articles font des parallèles entre les
deux, la comparaison a ses limites : les réseaux de neurones que l’on étudie
et utilise actuellement en informatique sont extrêmement simplistes si on les
compare au cerveau humain… L’intelligence artificielle n’est pour l’instant pas
aussi intelligente que les médias veulent le croire.

5.1.3 Propriété d’approximation universelle et réseaux

profonds

Le théorème suivant~ ? ? dit qu’un réseau feedforward à deux couches avec une
sortie linéaire et une fonction d’activation 𝑔 bornée croissante, continue (non
constante) peut approcher aussi finement que l’on veut n’importe quelle fonction
continue sur l’hypercube [0, 1]𝐷 du moment qu’il a suffisamment de neurones
sur sa couche intermédiaire.
Théorème 2 (Théorème d’approximation universel). Soit 𝑔 une fonction non
constante, bornée et croissante et continue. L’ensemble des fonctions sur l’hy-
percube [0, 1]𝐷 de la forme

𝑦(𝑥) = 𝜃𝑇 𝑔 (𝑊 𝑥 + 𝑏)

avec 𝑁 ∈ N, 𝑊 ∈ ℳ𝑁×𝐷 (R), 𝜃 ∈ R𝑁 et 𝑏 ∈ R𝑁 , est dense dans l’ensemble des

fonctions continues sur [0, 1]𝐷 .
50CHAPITRE 5. RÉSEAUX DE NEURONES FEED-FORWARD ET APPRENTISSAGE PROFOND

Sous des conditions un peu plus fortes sur 𝑔, on peut approcher n’importe quelle
fonction mesurable sur l’hypercube. En d’autres termes, on peut approcher aussi
finement que l’on veut n’importe quelle fonction sur un compact en dimension
finie avec un réseau de neurones à deux couches suffisamment grand. Le problème
est que la taille de la couche intermédiaire nécessaire peut-être tellement grande
que le réseau n’est pas utilisable ou optimisable en pratique. Or, en pratique,
il est souvent beaucoup plus utile d’utiliser des réseaux moins larges mais plus
profonds.

Deep learning.
Pendant longtemps, on se contentait d’utiliser des réseaux de neurones à
quelques couches, donc peu profonds, pour des raisons de temps de calcul. On
se contentait en général d’une quinzaine de couches au maximum. Les réseaux
de neurones modernes doivent un partie de leur succès retentissant dans de
nombreux domaines (image, son, vidéo, médecine, etc) au fait qu’ils utilisent
de très nombreuses couches, on parle alors d’apprentissage profond (ou deep
learning). Certains de ces réseaux peuvent avoir des milliers de couches, et
des millions de neurones. Pour entraîner de tels réseaux, qui dépendent de
milliers ou dizaines de milliers de paramètres, il faut des bases massives de
données d’entraînement. Le succès actuel des réseaux de neurones profonds est
en grande partie dû à l’utilisation de ces immenses masses de données.
Les réseaux de neurones et en particulier les réseaux profonds permettent de
construire des fonctions extrêmement sophistiquées des données d’entrée, à par-
tir des paramètres entre les noeuds du réseau. On parle aussi de representa-
tion learning. Ces paramètres sont appris automatiquement à partir d’une base
d’apprentissage. Cette délicate étape d’optimisation est l’objet de la prochaine
section.

5.2 Optimisation du réseau

On explique dans cette section comment estimer les paramètres 𝑊 du
réseau. Etant donnée une base d’apprentissage composée de 𝑁 vecteurs
d’entrée {𝑥(𝑚) }𝑚=1,…,𝑀 et d’un ensemble correspondant de vecteurs cibles
{𝑦(𝑚) }𝑚=1,…,𝑀 , on cherche les poids qui minimisent une fonction de perte (loss
function en anglais) agrégeant les erreurs de prédiction sur la base.
Une fonction de perte classique est l’erreur quadratique moyenne :

1 𝑀
ℒ(𝑊 ) = ̂ (𝑚) , 𝑊 ) − 𝑦(𝑚) ‖2 .
∑ ‖𝑦(𝑥
2 𝑚=1

Cette fonction de perte quadratique apparaît naturellement dans un problème

de régression si on suppose par exemple que les 𝑥(𝑚) sont des réalisations de va-
riables i.i.d., que chaque 𝑦(𝑚) suit une distribution gaussienne 𝒩(𝑦(𝑥
̂ (𝑚) , 𝑊 ), 𝜎2 )
5.2. OPTIMISATION DU RÉSEAU 51

et que l’on cherche les paramètres par maximum de vraisemblance. En effet, le

maximum de vraisemblance est calculé dans ce cas comme
‖𝑦(𝑚) −̂
𝑦(𝑥(𝑚) ,𝑊)‖2
−
argmax𝑊 Π𝑀
𝑚=1 𝑒
2𝜎2 ,

ce qui revient à minimiser ℒ(𝑊 ).

D’autres fonctions de perte beaucoup plus générales peuvent être utilisées selon
le type de problème à résoudre. Typiquement, pour des problèmes de classifica-
tion, on utilisera plutôt une fonction d’entropie croisée

𝑀
ℒ(𝑊 ) = − ∑ (𝑦(𝑚) 𝑙𝑛𝑦(𝑥
̂ (𝑚) , 𝑊 ) + (1 − 𝑦(𝑚) )𝑙𝑛(1 − 𝑦(𝑥
̂ (𝑚) , 𝑊 ))) .
𝑚=1

Pour ce type de problème, la couche de sortie a généralement un noeud séparé

pour chaque classe et utilise une fonction d’activation de type ‘softmax’, per-
mettant que la somme des sorties soit 1.
Dans le cas d’un problème de classification à plus de deux classes, il est usuel
de définir la fonction de perte de la manière suivante. Si 𝑦 ̂ = (𝑦1̂ … , 𝑦𝑀
̂ ) est la
sortie du réseau de neurones :
𝑀 𝑦̂
𝑒 𝑦(𝑚)
ℒ(𝑦,̂ 𝑦) = ∑ − log ( ).
𝑚=1
𝑒𝑦1̂ + ⋯ + 𝑒𝑦𝑀
̂

Remarquons qu’en général, la fonction de perte ℒ(𝑊 ) n’est pas une fonction
convexe des poids, elle peut donc être très difficile à optimiser. En pratique, on
l’optimise quand même par descente de gradient, en faisant donc comme si elle
était convexe.

5.2.1 Descente de gradient

L’optimisation du réseau se fait par descente de gradient, avec les étapes sui-
vantes :

1. On commence par initialiser les poids 𝑊 aléatoirement ;

2. On calcule le gradient de la fonction de perte ℒ par rapport à tous les
poids du réseau

𝜕ℒ
∇ℒ = { [𝑘]
}
𝜕𝑊𝑗𝑖
𝑖,𝑗,𝑘

en utilisant la dérivation en chaîne (backpropagation, voir plus loin) ;

52CHAPITRE 5. RÉSEAUX DE NEURONES FEED-FORWARD ET APPRENTISSAGE PROFOND

3. Pour un pas de descente 𝛼 > 0 donné, on met à jour les poids 𝑊

[𝑘] [𝑘] 𝜕ℒ
𝑊𝑗𝑖 ⟵ 𝑊𝑗𝑖 − 𝛼 [𝑘]
𝜕𝑊𝑗𝑖

et on retourne à l’étape 2, jusqu’à convergence.

Remarques :
— On peut aussi utiliser un algorithme de gradient conjugué ou du quasi-
newton pour cette optimisation, ce qui permet d’assurer que la fonction
de perte décroît à chaque itération (ce n’est pas le cas avec une descente
de gradient simple).
— Comme la fonction ℒ n’est pas convexe en 𝑊 , il peut être nécessaire de
relancer l’algorithme avec plusieurs initialisations différentes et de choisir
le résultat optimal.

5.2.2 Descente de gradient stochastique

Pour entraîner les réseaux de neurones sur de très grandes bases de données,
on peut utiliser une méthode de descente de gradient séquentielle, aussi appelée
descente de gradient stochastique. Le principe est de décomposer la fonction
d’erreur sous la forme
𝑁
ℒ(𝑤) = ∑ ℒ𝑛 (𝑤)
𝑛=1

où l’indice 𝑛 = 1 … 𝑁 désigne différentes observations (ou groupes d’observa-

tions) indépendantes (on parle aussi de batch de données). Un pas de descente
s’écrit
𝑊 𝑘+1 = 𝑊 𝑘 − 𝛼∇ℒ𝑛 (𝑤𝑘 ).

Cette mise à jour est répétée soit en choisissant 𝑛 au hasard, soit dans un ordre
prédéfini. On cycle sur les valeurs de 𝑛 et on recommence quand les 𝑁 données
ont toutes été utilisées. Chaque cycle sur l’ensemble des données est appelé une
époque (en anglais epoch).
On peut réinterpréter cette méthode comme une descente avec une version brui-
tée du gradient à chaque étape. Si on suppose que ∇ℒ(𝑤) varie lentement, une
époque est quasiment équivalente à une descente dans la direction −∇ℒ(𝑤) avec
le poids 𝛼.
Ce type de méthode a la bonne propriété de pouvoir échapper au minima locaux,
puisqu’un point stationnaire par rapport à 𝐿 n’est généralement pas stationnaire
pour ℒ𝑛 . Elle s’adapte aussi bien à l’apprentissage online, pour lequel les don-
nées ne sont pas toutes disponibles en même temps.
5.2. OPTIMISATION DU RÉSEAU 53

5.2.3 Calcul du gradient par Backpropagation

Pour calculer efficacement le gradient ∇ℒ, on utilise l’algorithme dit de back-

propagation.
Cet algorithme part de l’erreur de prédiction et la repropage à l’envers dans le
réseau vers les valeurs d’entrée pour calculer les dérivées par rapport à chaque
poids.
La backpropagation repose sur le principe de dérivation en chaîne. On rappelle
que si l’on a une fonction 𝑓 de R𝑛 dans R et une fonction ℎ de R𝑝 dans R𝑛 et
que l’on note $ L(x)= f�h(x)$ (avec ℎ𝑗 la cordonnée 𝑗 de ℎ), alors
𝑛
𝜕𝐿 𝜕𝑓 𝜕ℎ𝑗
=∑ .
𝜕𝑥𝑖 𝑗=1
𝜕ℎ𝑗 𝜕𝑥𝑖

𝜕𝐿
Dans ce qui suit, on fera un léger abus de notation et on écrira 𝜕ℎ𝑗 pour désigner
𝜕𝑓
le gradient 𝜕ℎ𝑗 . La dérivation en chaîne s’écrira donc
𝑛
𝜕𝐿 𝜕𝐿 𝜕ℎ𝑗
=∑ ,
𝜕𝑥𝑖 𝑗=1
𝜕ℎ𝑗 𝜕𝑥𝑖

où 𝐿 est vue comme fonction de 𝑥 dans la partie gauche de l’équation et comme

fonction de ℎ dans la partie droite.
Gardons les notations du paragraphe sur la propagation forward, et supposons
pour simplifier que la fonction d’activation soit la même sur toutes les couches,
on la note 𝑔. Notre but est de calculer, pour toutes les couches 𝑘 du réseau, la
[𝑘]
dérivée de ℒ par rapport aux poids 𝑊𝑗𝑖 et aux offsets 𝑏𝑗𝑘 .
On fait l’hypothèse pour l’instant que la fonction de perte est quadratique

1 𝑀
ℒ(𝑊 ) = ̂ (𝑚) , 𝑊 ) − 𝑦(𝑚) ‖2 .
∑ ‖𝑦(𝑥
2 𝑚=1
En dérivant, on a pour tout 𝑖, 𝑗, 𝑘
𝑀
𝜕ℒ 𝜕𝑦̂
[𝑘]
̂ (𝑚) , 𝑊 ) − 𝑦(𝑚) ,
= ∑ < 𝑦(𝑥 [𝑘]
>. (5.4)
𝜕𝑊𝑗𝑖 𝑚=1 𝜕𝑊𝑗𝑖

̂ 𝑊 ) = 𝑔(𝑧 [𝑙] ) avec

Par exemple, pour la dernière couche 𝑘 = 𝑙, on sait que 𝑦(𝑥,
[𝑙] [𝑙] [𝑙−1] [𝑙]
𝑧𝑗 = ∑ 𝑊𝑗𝑖 𝑎𝑖 + 𝑏𝑗 .
𝑖

On peut donc déjà calculer

[𝑙]
𝜕𝑦̂ 𝜕𝑧𝑗 [𝑙−1]
[𝑙]
= 𝑔′ (𝑧 [𝑙] ) [𝑙]
= 𝑔′ (𝑧 [𝑙] )𝑎𝑖 ,
𝜕𝑊𝑗𝑖 𝑊𝑗𝑖
54CHAPITRE 5. RÉSEAUX DE NEURONES FEED-FORWARD ET APPRENTISSAGE PROFOND

[𝑙] [𝑙−1]
en gardant en tête que 𝑧𝑗 et 𝑎𝑖 sont ici des fonctions de (𝑥(𝑚) , 𝑊 ). Ainsi,
pour tous les poids de la dernière couche 𝑙,
𝑀
𝜕ℒ [𝑙−1]
[𝑙]
̂ (𝑚) , 𝑊 ) − 𝑦(𝑚) , 𝑔′ (𝑧 [𝑙] (𝑥(𝑚) , 𝑊 ))𝑎𝑖
= ∑ < 𝑦(𝑥 (𝑥(𝑚) , 𝑊 ) > .
𝜕𝑊𝑗𝑖 𝑚=1

𝜕ℒ
Regardons maintenant comment calculer [𝑘] pour les autres couches du réseau.
𝜕𝑊𝑗𝑖
𝜕 𝑦̂
Grâce à l’équation~(5.4), on sait qu’il suffit de calculer [𝑘] . Remarquons que
𝜕𝑊𝑗𝑖
[𝑘] [𝑘]
la sortie 𝑦(𝑥,
̂ 𝑊 ) de dépend des poids 𝑊𝑗𝑖 et de 𝑏𝑗 qu’à travers la valeur de
[𝑘]
𝑧𝑗 . En d’autres termes, il existe 𝑓 telle que
[𝑘] [𝑘′ ] [𝑘′ ]
𝑦(𝑊
̂ ) = 𝑓(𝑧𝑗 , {𝑊𝑗′ 𝑖′ , 𝑏𝑗′ }(𝑖′ ,𝑗′ ,𝑘′ )≠(𝑖,𝑗,𝑘) ).

On rappelle que
[𝑘] [𝑘] [𝑘−1] [𝑘]
𝑧𝑗 = ∑ 𝑊𝑗𝑖 𝑎𝑖 + 𝑏𝑗 .
𝑖

Avec le même abus de notation que plus haut, la dérivée de 𝑦 ̂ par rapport au
[𝑘] [𝑘]
poids 𝑊𝑗𝑖 et à l’offset 𝑏𝑗 s’écrit donc
[𝑘]
𝜕𝑦̂ 𝜕𝑦̂ 𝜕𝑧𝑗 𝜕𝑦̂ [𝑘−1] 𝜕𝑦̂ 𝜕𝑦̂
[𝑘]
= [𝑘] [𝑘]
= 𝑎
[𝑘] 𝑖
, et [𝑘]
= [𝑘]
.
𝜕𝑊𝑗𝑖 𝜕𝑧𝑗 𝜕𝑊𝑗𝑖 𝜕𝑧𝑗 𝜕𝑏𝑗 𝜕𝑧𝑗
[𝑘−1] [𝑘−1]
Comme les valeurs 𝑎𝑖 = 𝑔(𝑧𝑖 ) sont connues, ces équations permettent de
calculer le gradient de 𝑦 ̂ et donc de ℒ par rapport aux paramètres du réseau
(les 𝑊 et les 𝑏) très simplement si on connaît déjà le gradient de 𝑦 ̂ par rapport
[𝑘]
aux valeurs 𝑧𝑗 .
𝜕 𝑦̂
Montrons maintenant que calculer les dérivées partielles [𝑘] se fait également
𝜕𝑧𝑗
très simplement en propageant les valeurs de la couche de sortie vers la couche
[𝑘] [𝑘+1]
d’entrée. Remarquons que 𝑦 ̂ ne dépend de 𝑧𝑗 qu’à travers les valeurs 𝑧𝑙 des
[𝑘]
neurones de la couche 𝑘 + 1 à laquelle le neurone 𝑧𝑗 est connecté. Or,
[𝑘+1] [𝑘] [𝑘]
𝑧𝑙 = ∑ 𝑊𝑙𝑖 𝑔(𝑧𝑖 ).
𝑖

On en déduit que
[𝑘+1]
𝜕𝑦̂ 𝜕𝑦̂ 𝜕𝑧𝑙 𝜕𝑦̂ [𝑘+1] [𝑘]
[𝑘]
=∑ [𝑘+1] [𝑘]
=∑ [𝑘+1]
𝑊𝑙𝑗 𝑔′ (𝑧𝑗 ).
𝜕𝑧𝑗 𝑙 𝜕𝑧𝑙 𝜕𝑧𝑗 𝑙 𝜕𝑧𝑙
𝜕 𝑦̂
Ainsi, si on connaît toutes les dérivées partielles [𝑘+1] pour la couche 𝑘 + 1,
𝜕𝑧𝑙
𝜕 𝑦̂
on peut calculer toutes les dérivées partielles [𝑘] pour la couche 𝑘 par simple
𝜕𝑧𝑗
5.3. RÉGULARISATION 55

combinaison linéaire. L’algorithme~ ?? est linéaire en le nombre de neurones du

réseau. Le même type d’algorithme peut être utilisé pour calculer des dérivées
d’ordre supérieur dans le réseau (comme des hessiennes par exemple).

Algorithme : 1. Pour un vecteur d’entrée 𝑥(𝑚) de la base d’apprentissage,

appliquer l’algorithme de forwardpropagation pour calculer toutes les valeurs
des neurones du réseau.

2. Pour 𝑘 décroissant de 𝐾 à 1, calculer les dérivées partielles de ℒ par

rapport aux noeuds de la couche 𝑘.
3. En déduire les dérivées partielles de ℒ par rapport à chacun des para-
mètres du réseau.

5.3 Régularisation

Le nombre d’entrées et de sorties dans un réseau est généralement déterminé par

les données d’apprentissage, mais le nombre total 𝑀 de neurones des couches
intermédiaires et le nombre de ces couches est un paramètre qui doit être ajusté
pour obtenir de bonnes performances tout en évitant le sur-apprentissage.

Si le nombre 𝑀 est choisi très grand, le risque de sur-apprentissage l’est aussi.

Une régularisation est alors introduite dans l’algorithme pour réduire l’erreur
de généralisation sans perturber l’erreur d’apprentissage. Différents types de
régularisation peuvent être envisagées :

1. La pénalisation d’une norme des paramètres dans la fonction de perte

ℒ𝑡𝑟𝑎𝑖𝑛 (𝑊 ). On pénalise seulement les poids 𝑊 , pas les offsets 𝑏, via des
pénalités quadratiques (de type ridge) ou 𝐿1 (de type Lasso).
2. La restriction de l’espace des paramètres : on peut par exemple imposer
certaines symétries sur 𝑊 .
3. Early stopping : consiste à entraîner le réseau en utilisant à la fois une base
d’entraînement et une base de test, et à stopper l’entraînement lorsque
ℒ𝑡𝑒𝑠𝑡 (𝑊 ) se met à ré-augmenter
4. Dropout : consiste à désactiver certains neurones à chaque étape de la
descente de gradient, pour éviter le sur-apprentissage
5. Augmentation de données : consiste à augmenter la taille de la base
d’apprentissage en lui ajoutant des données obtenues par transformations
(ajout de bruit, transformations géométriques, etc) des données de la base
de départ.
56CHAPITRE 5. RÉSEAUX DE NEURONES FEED-FORWARD ET APPRENTISSAGE PROFOND

5.3.1 Régularisation quadratique des poids

Voyons ce qui se passe lorsqu’on ajoute à la fonction de perte ℒ(𝑊 ) un terme

pénalisant la norme 𝑙2 des poids. La fonction devient
𝜆
ℒ𝑅 (𝑊 ) = ℒ(𝑊 ) + ‖𝑊 ‖22 .
2

Remarque : on a
∇ℒ𝑅 (𝑊 ) = ∇ℒ(𝑊 ) + 𝜆𝑊 ,
donc la descente de gradient devient

𝑊𝑡+1 = 𝑊𝑡 + 𝛼∇ℒ𝑅 (𝑊𝑡 ) = (1 − 𝛼𝜆)𝑊𝑡 − 𝛼ℒ(𝑊𝑡 ).

Si 𝑊 ∗ est un minimum local de ℒ, on peut écrire au voisinage de 𝑊 ∗ ,

1
ℒ(𝑊 ) ≃ ℒ(𝑊 ∗ ) + (𝑊 − 𝑊 ∗ )𝑡 𝐻ℒ (𝑊 ∗ )(𝑊 − 𝑊 ∗ )
2
avec 𝐻ℒ la matrice hessienne de ℒ. Ainsi, au voisinage de 𝑊 ∗ , le gradient ∇ℒ
est bien approché par 𝐻(𝑊 − 𝑊 ∗ ) et

∇ℒ𝑅 (𝑊 ) ≃ 𝐻(𝑊 − 𝑊 ∗ ) + 𝜆𝑊 ,

donc le minimum local 𝑊𝑅∗ correspondant devrait vérifier (en diagonalisant 𝐻 =

𝑄Λ𝑄𝑡 avec Λ = diag(𝜆1 , … , 𝜆𝑛 ))

𝑊𝑅∗ ≃ (𝐻 + 𝜆𝐼𝑑)−1 𝐻𝑊 ∗ = 𝑄(Λ + 𝜆𝐼𝑑)−1 𝑄𝑡 𝑊 ∗ .

En première approximation, le minimum local 𝑊𝑅∗ est donc une version de 𝑊

dans laquelle on a réduit les coefficients dans la base 𝑄 par les quantités 𝜆 𝜆+𝜆
𝑖
.
𝑖

5.3.2 Régularisation 𝑙1 des poids

On peut ajouter à la fonction de perte ℒ(𝑊 ) un terme pénalisant la norme 𝑙1

des poids. La fonction devient

ℒ𝑅 (𝑊 ) = ℒ(𝑊 ) + 𝜆‖𝑊 ‖1 .

Remarque : on a

∇ℒ𝑅 (𝑊 ) = ∇ℒ(𝑊 ) + 𝜆sign(𝑊 ),

donc la descente de gradient devient

𝑊𝑡+1 = 𝑊𝑡 + 𝛼∇ℒ𝑅 (𝑊𝑡 ) = 𝑊𝑡 − 𝛼ℒ(𝑊𝑡 ) − 𝛼sign(𝑊𝑡 ).

5.3. RÉGULARISATION 57

Si 𝑊 ∗ est un minimum local de ℒ, on peut toujours écrire au voisinage de 𝑊 ∗ ,

1
ℒ𝑅 (𝑊 ) ≃ ℒ(𝑊 ∗ ) + (𝑊 − 𝑊 ∗ )𝑡 𝐻ℒ (𝑊 ∗ )(𝑊 − 𝑊 ∗ ) + 𝜆‖𝑊 ‖1 .
2
Pour donner un peu d’intuition à cette régularisation, on peut supposer (c’est
évidemment faux en général) que la hessienne 𝐻ℒ (𝑊 ∗ ) est diagonale avec des
coefficients 𝐻𝑖𝑖 sur la diagonale. On peut alors réécrire

1
ℒ𝑅 (𝑊 ) ≃ ℒ(𝑊 ∗ ) + ∑ ( 𝐻𝑖𝑖 (𝑊𝑖 − 𝑊𝑖∗ )2 + 𝜆|𝑊𝑖 |) .
𝑖
2

Ainsi, le minimum local 𝑊𝑅∗ correspondant devrait vérifier

𝜆
max(𝑊𝑖∗ − 𝐻𝑖𝑖 , 0) si 𝑊𝑅∗ ≥ 0
(𝑊𝑅∗ )𝑖 = { 𝜆
max(𝑊𝑖∗ + 𝐻𝑖𝑖 , 0) si 𝑊𝑅∗ < 0.

La régularisation par une norme 𝑙1 revient donc dans ce cas à appliquer un

seuillage doux aux coefficient de 𝑊 ∗ , et favorise donc les résultats parcimonieux.

5.3.3 Invariances et réseaux convolutionnels (CNN)

Dans de nombreuses applications, on peut souhaiter que les prédictions du

réseau soient invariantes sous certaines transformations des données d’entrée
(translation, rotation, etc). C’est par exemple le cas en traitement d’images. Si
la base d’apprentissage est suffisamment importante, le réseau peut apprendre
cette invariance au moins approximativement. Mais cette approche n’est pas
toujours la meilleure, surtout si la base d’apprentissage est de taille limitée, ou
s’il y a beaucoup d’invariances à apprendre. Plusieurs alternatives existent :

1. enrichir la base d’apprentissage artificiellement avec de nouveaux

exemples créés en appliquant des transformations aux exemples de la
base de départ ;
2. ajouter dans la fonction de perte un terme qui pénalise un changement
dans le résultat du réseau si la donnée d’entrée est transformée
3. extraire des données d’entrée des caractéristiques invariantes et utiliser
un réseau qui prend ces caractéristiques en entrée ;
4. construire un réseau qui par sa structure respecte intrinsèquement ces
invariances. C’est le cas par exemple des réseaux convolutionnels utilisés
en vision par ordinateur.
58CHAPITRE 5. RÉSEAUX DE NEURONES FEED-FORWARD ET APPRENTISSAGE PROFOND
Chapitre 6

SuperLearner : un exemple
d’Ensembl Learning

Les chapitres précédents ont exposé des méthodes très différentes d’apprentis-
sage ayant chacune leurs avantages et leurs défauts en termes d’interprétabilité,
de prédiction, de sélection de variables ou de temps de calcul.
Le choix de la famille d’algorithmes retenue peut être guidé par la modélisa-
tion du problème, la volonté de privilégier l’un des aspects cités ci-dessus, ou
simplement la comparaison de la qualité de la prédiction à l’aide de validation
croisée.
Une autre option peut être de faire collaborer les différentes familles d’algo-
rithmes en les combinant soit via une combinaison linéaire, soit via un vote
majoritaire. On parle alors d’Ensembl Learning (c’est une idée que nous avons
déjà rencontrée au sujet des forêts aléatoires).

6.1 Le package Superlearner

Le package Superlearner (Van der Laan et al., 2007) combine des algorithmes
𝐴1 , … , 𝐴𝐾 de la façon suivante :

1. Le jeu d’apprentissage est découpé en K folds et chaque algorithme est

appliqué pour faire une prédiction sur chaque fold.

Chaque individu 𝑖 du jeu d’apprentissage a alors une vraie valeur 𝑌𝑖 et 𝐾 pré-

diction 𝑍𝑖,1 , … , 𝑍𝑖,𝐾 .

2. Un modèle linéaire (gaussien ou logistique) est appliqué pour prédire 𝑌

en fonction des 𝑍𝑘

59
60CHAPITRE 6. SUPERLEARNER : UN EXEMPLE D’ENSEMBL LEARNING

3. Pour prédire 𝑌 pour un nouvel individu, cette combinaison linéaire est

appliquée aux prédictions des 𝐾 algorithmes pour cet individu.

6.2 Un exemple d’utilisation

Considérons le jeu de données suivant disponible sur Kaggle : [Link]

[Link]/nareshbhat/health-care-data-set-on-heart-attack-possibility
Ce jeu de données contient 13 variables prédictives servant à diagnostiquer la
quatorzième, qui dit si l’individu en question est considéré comme à risque élevé
d’accident cardio-vasculaire.
heartdata <- [Link]("data/[Link]")
heartdata <- as_tibble(heartdata)
str(heartdata)

## tibble [303 x 14] (S3: tbl_df/tbl/[Link])

## $ age : int [1:303] 63 37 41 56 57 57 56 44 52 57 ...
## $ sex : int [1:303] 1 1 0 1 0 1 0 1 1 1 ...
## $ cp : int [1:303] 3 2 1 1 0 0 1 1 2 2 ...
## $ trestbps: int [1:303] 145 130 130 120 120 140 140 120 172 150 ...
## $ chol : int [1:303] 233 250 204 236 354 192 294 263 199 168 ...
## $ fbs : int [1:303] 1 0 0 0 0 0 0 0 1 0 ...
## $ restecg : int [1:303] 0 1 0 1 1 1 0 1 1 1 ...
## $ thalach : int [1:303] 150 187 172 178 163 148 153 173 162 174 ...
## $ exang : int [1:303] 0 0 0 0 1 0 0 0 0 0 ...
## $ oldpeak : num [1:303] 2.3 3.5 1.4 0.8 0.6 0.4 1.3 0 0.5 1.6 ...
## $ slope : int [1:303] 0 0 2 2 2 1 1 2 2 2 ...
## $ ca : int [1:303] 0 0 0 0 0 0 0 0 0 0 ...
## $ thal : int [1:303] 1 2 2 2 2 1 2 3 3 2 ...
## $ target : int [1:303] 1 1 1 1 1 1 1 1 1 1 ...
Commençons par séparer le jeu en apprentissage/test.
inTrain <- createDataPartition(
y = heartdata$target,
p = .75,
list = FALSE
)

hearttraining <- heartdata %>% slice(n=inTrain)

hearttest <- heartdata %>% slice(n=-inTrain)

x_train <- hearttraining %>% select(-target)

y_train <- hearttraining$target
x_test <- hearttest %>% select(-target)
6.2. UN EXEMPLE D’UTILISATION 61

y_test <- hearttest$target

6.2.1 Utilisation basique

Faire tourner SuperLearner nécessite de préciser deux choses pour définir la

librairie (library) des algorithmes candidats :
— prediction algorithm : le ou les algorithmes candidats. Une liste prédéfinie
existe
— screening : les variables prédictives choisies. Par défaut, toutes les va-
riables sont retenues.
Dans un premier temps, ce paragraphe illustre l’utilisation de SuperLearner
dans le cas où toutes les variables prédictives sont utilisées et les algorithmes
sont choisis parmi ceux par défaut.
La liste des algorithmes de prédiction et de sélection prédéfinis sont les suivants.
listWrappers()

## All prediction algorithm wrappers in SuperLearner:

## [1] "[Link]" "[Link]" "[Link]"
## [4] "[Link]" "[Link]" "[Link]"
## [7] "[Link]" "[Link]" "[Link]"
## [10] "[Link]" "[Link]" "[Link]"
## [13] "[Link]" "[Link]" "[Link]"
## [16] "[Link]" "[Link]" "[Link]"
## [19] "[Link]" "[Link]" "[Link]"
## [22] "[Link]" "[Link]" "[Link]"
## [25] "[Link]" "[Link]" "[Link]"
## [28] "[Link]" "[Link]" "[Link]"
## [31] "[Link]" "[Link]" "[Link]"
## [34] "[Link]" "[Link]" "[Link]"
## [37] "[Link]" "[Link]" "[Link]"
## [40] "[Link]" "[Link]"
##
## All screening algorithm wrappers in SuperLearner:
## [1] "All"
## [1] "[Link]" "[Link]" "[Link]"
## [4] "[Link]" "[Link]" "[Link]"
## [7] "[Link]" "[Link]"
On remarque que la liste des algorithmes contient notamment
— l’algorithme de prédiction par la moyenne ([Link], qui est à priori
mauvais mais permet du coup d’établir une référence),
62CHAPITRE 6. SUPERLEARNER: UN EXEMPLE D’ENSEMBL LEARNING

— les forêts aléatoires avec [Link]

— les régressions pénalisées avec [Link]
— les SVM avec [Link]
— les réseaux de neurones feed-forward avec [Link]
Pour voir comment sont choisis les paramètres des différentes méthodes, il faut
aller voir leur code
[Link]

## function (Y, X, newX, family, obsWeights, model = TRUE, ...)

## {
## if ([Link](X)) {
## X = [Link](X)
## }
## [Link] <- glm(Y ~ ., data = X, family = family, weights = obsWeights,
## model = model)
## if ([Link](newX)) {
## newX = [Link](newX)
## }
## pred <- predict([Link], newdata = newX, type = "response")
## fit <- list(object = [Link])
## class(fit) <- "[Link]"
## out <- list(pred = pred, fit = fit)
## return(out)
## }
## <bytecode: 0x557e1c849940>
## <environment: namespace:SuperLearner>
Si d’autres réglages sont souhaités, il faut définir d’autres algorithmes que ceux
par défaut (cf plus loin).

6.2.2 Apprentissage basique

Commençons par une version simple, où aucun screening n’est spécifié (toutes les
variables sont retenues) et suels des algorithmes par défaut intègrent le librairie,
par exemple la moyenne, les régressions pénalisées, les forêts alétoires et le svm
linéaire.
sl = SuperLearner(Y = y_train, X = x_train, family = binomial(),
[Link] = c("[Link]", "[Link]", "[Link]","[Link]"))
sl

##
## Call:
## SuperLearner(Y = y_train, X = x_train, family = binomial(), [Link] = c("[Link]"
## "[Link]", "[Link]", "[Link]"))
6.2. UN EXEMPLE D’UTILISATION 63

##
##
## Risk Coef
## SL.mean_All 0.2508233 0.0000000
## SL.glmnet_All 0.1281099 0.2225097
## SL.ranger_All 0.1260757 0.2900443
## SL.svm_All 0.1226410 0.4874460
La colonne Risk donne le risque quadratique moyen associé à chaque algorithme
(par validation croisée), la colonne Coef le poids attribué à chaque algorithme
dans la méthode d’ensemble.

6.2.3 Prédiction

Une fonction predict existe, qui permet de donner une prédiction sur tout nouvel
individu, à la fois par la méthode d’ensemble et pour chacune des méthodes
utilisés. Affichons ces prédictions pour les trois premiers individus de l’ensemble
test, d’abors pour la méthode d’ensemble
test_pred <- predict(sl,x_test)
test_pred$pred[1:3]

## [1] 0.5072891 0.8335444 0.9386995

puis pour les méthodes individuelles
test_pred$[Link][1:3,]

## SL.mean_All SL.glmnet_All SL.ranger_All SL.svm_All

## [1,] 0.5263158 0.6130923 0.5770000 0.4175121
## [2,] 0.5263158 0.8038569 0.7276667 0.9100965
## [3,] 0.5263158 0.9575578 0.8882444 0.9601132
Remarques dans le cas d’une variable 𝑌 binaire :
— On peut à partir de cette prédiction créer des matrices de confusion ou
déterminer l’AUC de la méthode comme déjà fait pour les méthodes
isolément
— en précisant method=[Link] dans les paramètres de la fonction,
on peut demander à SuperLearner d’optimiser directement l’AUC plutôt
que l’erreur quadratique moyenne.

6.2.4 Nested Cross Validation

Pour voir si SuperLearner améliore réellement les performances par rapport

à une méthode seule, il faut le comparer à celles-ci, à travers une couche de
64CHAPITRE 6. SUPERLEARNER : UN EXEMPLE D’ENSEMBL LEARNING

validation supérieure (c’est à dire que la validation croisée d’apprentisage de SL

se fera à l’intérieur de chaque fold de la couche supérieure).

La fonction [Link] est prévue pour cela.

cv_sl = [Link](Y = y_train, X = x_train, family = binomial(),
V = 10,
[Link] = c("[Link]", "[Link]", "[Link]","[Link]"))

summary(cv_sl)

##
## Call:
## [Link](Y = y_train, X = x_train, V = 10, family = binomial(), [Link] =
## "[Link]", "[Link]", "[Link]"))
##
## Risk is based on: Mean Squared Error
##
## All risk estimates are based on V = 10
##
## Algorithm Ave se Min Max
## Super Learner 0.13539 0.0131236 0.080959 0.18890
## Discrete SL 0.13894 0.0136349 0.087475 0.19305
## SL.mean_All 0.25178 0.0019204 0.246564 0.26625
## SL.glmnet_All 0.13476 0.0141777 0.071440 0.20874
## SL.ranger_All 0.12961 0.0115004 0.087475 0.16820
## SL.svm_All 0.13176 0.0141141 0.064106 0.19305
plot(cv_sl) + theme_bw()
6.2. UN EXEMPLE D’UTILISATION 65

SL.ranger_All

SL.svm_All

SL.glmnet_All
Method

Super Learner

Discrete SL

SL.mean_All

0.10 0.15 0.20 0.25

V−fold CV Risk Estimate

6.2.5 Ajout de pré-sélection de variables

Des variables peuvent sélectionnées, soit à travers des fonctions existantes (cf
listWrappers(), par exemple [Link] qui ne garde que les variables dont la
corrélation avec 𝑦 est en valeur absolue d’au moins 0.1 ) soit en en créant par
soi-même.
Si par exemple on souhaite voir si l’âge, le sexe et le cholesterol suffisent
my_screening <- function (Y, X, family, obsWeights, id, ...) {
the_vars <- c("age", "sex",
"chol")
whichVariable <- colnames(X) %in% the_vars
return(whichVariable)
}

On peut alors choisir les combinaisons algorithme/screening qu’on souhaite faire

participer à l’ensemble
sl = SuperLearner(Y = y_train, X = x_train, family = binomial(),
[Link] = list("[Link]", c("[Link]","[Link]"), c("[Link]

6.2.6 Ajout de nouveaux algorithmes de prédiction

On peut également créer de nouveaux algorithmes

66CHAPITRE 6. SUPERLEARNER : UN EXEMPLE D’ENSEMBL LEARNING

— soit en les créant ad-hoc

SL.my_tree <- function (Y, X, newX, family, obsWeights, ...) {
pred <- (newX$age >65) *
(newX$chol > 240) +
(newX$age >40 ) *
(newX$chol >290)
fit <- list(object = "my_tree")
class(fit) <- "SL.my_tree"
out <- list(pred = pred, fit = fit)
return(out)
}

— soit en prenant un algorithme prédéfini en modifiant ses paramètres, par

exemple ici en utilisant la méthode CART pour une profondeur d’arbre
de 3 à 6.
rpart_algorithms <- [Link]("[Link]", tune = list(maxdepth = 3:6))

sl = SuperLearner(Y = y_train, X = x_train, family = binomial(),

[Link] = c("SL.my_tree", rpart_algorithms$names))
sl

##
## Call:
## SuperLearner(Y = y_train, X = x_train, family = binomial(), [Link] = c("SL.my_tr
## rpart_algorithms$names))
##
##
## Risk Coef
## SL.my_tree_All 0.5701754 0.04916744
## SL.rpart_1_All 0.1907092 0.54295653
## SL.rpart_2_All 0.1926907 0.17593411
## SL.rpart_3_All 0.1944610 0.23194193
## SL.rpart_4_All 0.1944610 0.00000000
Chapitre 7

TP 1 : Manipulation de
données et validation
croisée

On considère le jeu de données airquality.

data(airquality)

7.1 Manipulation de données

1. Stocker le jeu de données dans un objet de type tibble et afficher les cinq
premières lignes à l’aide de la fonction slice()
2. Afficher la première ligne de chaque mois grâce aux fonctions group_by()
et slice()
3. Supprimer les lignes ayant ayant au moins une donnée manquante
4. A l’aide de la fonction summarise, déterminer la mediane du vent, puis,
en ajoutant la fonction group_by(), la médiane du vent par mois.
5. A l’aide des fonctions filter et select, afficher le taux d’ozone et la vitesse
du vent des jours ayant une température d’au moins 90.
6. A l’aide de la fonction mutate(), ajouter une variable high qui vaut 1
pour les jours ayant un taux d’ozone d’au moins 60, et 0 sinon.

67
68CHAPITRE 7. TP 1 : MANIPULATION DE DONNÉES ET VALIDATION CROISÉE

7.2 Apprentissage pour prédire le taux d’ozone

7. Séparer le jeu de données en un jeu d’apprentissage et un jeu test selon
des proportions 2/3 1/3.
8. On cherche à prédire le taux d’ozone à l’aide d’un modèle linéaire gaussien
et comparant les modèles
— 𝑀0 : moyenne seule
— 𝑀1 : Température
— 𝑀2 : Température et vent
— 𝑀3 : Température, vent et [Link]
— 𝑀4 : Température, vent, [Link] et mois
Réaliser cette tâche avec pour critère l’erreur quadratique moyenne et en
opérant le choix de modèle par validation croisée.
Comment évaluer l’erreur quadratique moyenne de la méthode choisie ?

9. Reprendre les questions précédentes pour prédire la variable ‘high’.

Chapitre 8

TP2 - Méthodes d’arbres

Les questions ci-dessous peuvent être traités soit méthode par méthode avec les
packages adaptés (rpart pour l’algorithme CART, ranger ou randomForest pour
les forêts aléatoires), soit de façon unifiée avec le package caret.

1. Récupérer le jeu de données [Link] disponible sur Moodle ou dans

Kaggle ([Link]
heart-attack-possibility). Le séparer en jeu de données/d’apprentissage .

8.1 CART
2. Apprendre un arbre de classification pour la prédiction des individus à
risque. Le représenter.
3. Relancer plusieurs fois le codes des questions précédentes et comparer les
arbres. Commenter.

8.2 Forêts aléatoires

4. Reprendre les questions précédentes à l’aide de forêts aléatoires. Com-
menter.
5. Quelles sont les variables les plus importantes pour la prédiction du risque
caridio-vasculaire ?

69
70 CHAPITRE 8. TP2 - MÉTHODES D’ARBRES
Chapitre 9

TP3 - Modèles linéaires

pénalisés

9.1 Avec glmnet

1. Récupérer les données [Link] disponibles sur Moodle. Elles sont issues
du package [Link] mais modifiées pour supprimer les gènes appa-
raissant en double dans les données initiales. Elles comprennent la mesure
de l’expression d’un peu moins de 2000 gènes sur 62 échantillons de tissus
du colon, ainsi que de l’information concernant le statut tumoral ou non
dudit tissu.
2. Peut-on mettre en place une règle de prédiction du statut tumoral à l’aide
de le régression logistique standard (fonction glm) ? Commenter.
3. Mettre en place, grâce au package glmnet, une régression ridge et tracer
le graphe de l’évolution des coefficients en fonction de la pénalité 𝑙𝑎𝑚𝑏𝑑𝑎.

Faire de même avec une régression lasso et une régression elastic-net de para-
mètre 𝛼 = .5. Comparer les différents graphes et commenter.

4. On décide pour le moment de choisir la méthode lasso. Opérer le choix

de 𝜆

a. Par validation croisée (fonction [Link])

b. Par stability selection

Evaluer la qualité des modèles retenus sur l’échantillon test.

5. Quel autre paramètre pourrait-on régler par validation croisée afin d’élar-
gir la famille de modèles considérés ?

71
72 CHAPITRE 9. TP3 - MODÈLES LINÉAIRES PÉNALISÉS

9.2 Avec caret

6. Reprendre le jeu de données [Link] disponible sur Moodle ou
dans Kaggle ([Link]
set-on-heart-attack-possibility). Traiter à l’aide du package caret
l’apprentissage de la variable target à l’aide de la méthode glmnet.
Chapitre 10

TP4 - SVM

10.1 Avec le package e1071

library(tidyverse)
library(caret)
library(e1071)
library(kernlab)

1. Charger le jeu de données iris, introduire une variable binaire à prédire

qui indique qu’une fleur est de l’espèce virginica ou non, et restreindre
le jeu de données aux variables concernant les pétales et cette variable à
prédire. Séparer également le jeu en apprentissage/test.

73
74 CHAPITRE 10. TP4 - SVM

[Link] 6

target
4 no
yes

0.0 0.5 1.0 1.5 2.0 2.5

[Link]

2. A l’aide de la fonction svm, mettre en place l’apprentissage par la mé-

thode linéaire et par noyau gaussien (avec les valeurs de gamma par dé-
faut). Comparer la qualité des prédictions de ces méthodes sur l’ensemble
de test. Commenter.
3. Dans le cas du noyau gaussien, proposer une manière de choisir la valeur
de gamma de façon donnée-dépendante (data-driven) ?
4. Reprendre les questions 1 et 2 avec l’espèce versicolor.

10.2 Avec caret

6. Reprendre le jeu de données [Link] disponible sur Moodle ou
dans Kaggle ([Link]
set-on-heart-attack-possibility). Traiter à l’aide du package caret
l’apprentissage de la variable target à l’aide d’une méthode SVM.

Le faire également pour la méthode des 𝑘 plus proches voisins.

Chapitre 11

TP5 - Réseaux de neurones

11.1 Exercice 1

Considérons la fonction binaire XOR(𝑥1 , 𝑥2 ) du OU exclusif entre deux variables

binaires : XOR prend la valeur 1 si et seulement si l’un des variables vaut 0 et
l’autre 1.

1. Montrer qu’il n’est pas possible de définir cette fonction à partir d’un
modèle linéaire.

2. Montrer qu’il est existe de multiples façon d’y arriver à l’aide du réseau
de neurones suivant

75
76 CHAPITRE 11. TP5 - RÉSEAUX DE NEURONES

x1

x2

11.2 Exercice 2 - Symétries du réseau

Pour un réseau à 1 couche, 𝑀 neurones intermédiaires et une fonction d’acti-

vation impaire, montrer que la fonction de perte quadratique ℒ(𝑊 ) présente
𝑀 axes de symétrie (on peut remplacer un poids par son inverse et compenser
ce changement de signe sur l’arête suivante) et que chaque vecteur de poids a
donc 2𝑀 vecteurs de poids qui lui sont équivalents. Montrer également qu’en
échangeant les arêtes entre elles, la fonction représentée par le réseau ne change
pas, ce qui implique également que chaque vecteur de poids a 𝑀 ! vecteurs de
poids qui lui sont équivalents de cette manière. En déduire que chaque vecteur
de poids a en fait 𝑀 !2𝑀 vecteurs équivalents.

11.3 Exercice 3

On propose dans ce qui suit de créer et d’entraîner un réseau très simple à deux
couches et 𝑑 = 3 neurones. Ce réseau prend un scalaire 𝑥 en entrée et donne un
scalaire 𝑦 en sortie.

La première couche du réseau est représentée par une matrice de poids 𝑊 [1]
de taille 3 × 1 et un vecteur d’offset 𝑏[1] à 3 lignes. On utilise une fonction
11.3. EXERCICE 3 77

d’activation tanh. A la sortie de la première couche on observe donc

𝐴[1] = tanh(𝑍 [1] ) avec 𝑍 [1] = 𝑊 [1] 𝑥 + 𝑏[1]

La matrice de poids 𝑊 [2] permettant de passer de la couche cachée à la sortie 𝑦

a donc 1 lignes et 3 colonnes, et le vecteur d’offset 𝑏[2] est un scalaire. La sortie
𝑦 ̂ est donc liée à 𝐴[1] par la relation

𝑦 ̂ = 𝑊 [2] 𝐴[1] + 𝑏[2] .

1. Dessiner ce réseau. Quelles sont la dimension de 𝐴[1] ?

̂ 𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) représentée par ce
2. Ecrire la fonction complète 𝑦(𝑥,
réseau.

[2] [1] [1] [2] [1] [1] [2] [1] [1]

𝑦 = 𝑊1 𝑡𝑎𝑛ℎ(𝑊1 𝑥+𝑏1 )+𝑊1 𝑡𝑎𝑛ℎ(𝑊2 𝑥+𝑏2 )+𝑊1 𝑡𝑎𝑛ℎ(𝑊3 𝑥+𝑏3 )+𝑏[2]

On souhaite utiliser ce réseau pour faire de la régression à partir de

𝑀 observations {(𝑥(𝑚) , 𝑦(𝑚) )}𝑚=1,…,𝑀 . On chercher donc les paramètres
(𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) qui minimisent la fonction de perte quadratique
𝑀
ℒ(𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) = ∑ ‖𝑦(𝑥
̂ (𝑚) , 𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) − 𝑦(𝑚) ‖2 .
𝑚=1

3. a. Quelle est la dérivée de ℒ par rapport à 𝑦 ̂ ?

b. Quelle est la dérivée de ℒ par rapport à 𝑊 [2] ?

c. Quelle est la dérivée de ℒ par rapport à 𝑏[2] ?
d. Quelle est la dérivée de ℒ par rapport à 𝐴[1] ?
e. Quelle est la dérivée de ℒ par rapport à 𝑍 [1] ?
f. Quelle est la dérivée de ℒ par rapport à 𝑊 [1] ?
g. Quelle est la dérivée de ℒ par rapport à 𝑏[1] ?

4. Pour créer la base des données d’entraînement, prendre par exemple,

pour les 𝑥(𝑚) , 30 points uniformément répartis sur l’intervalle [−1, 1] et
𝑦(𝑚) = 𝑓(𝑥(𝑚) ) avec 𝑓(𝑥) = 𝑥2 .
5. Initialiser le réseau avec de poids aléatoires et faibles (par exemple dans
[−.1, .1])
6. Entraîner le réseau en effectuant une descente de gradient, dans un pre-
mier temps avec un pas de 0.01.
7. Comparer la fonction apprise par notre réseau avec la fonction 𝑓 utilisée
pour créer les données.
78 CHAPITRE 11. TP5 - RÉSEAUX DE NEURONES

8. La fonction apprise par le réseau est-elle une bonne approximation de la

fonction 𝑓 en dehors de l’intervalle [−1, 1] ?
9. Utiliser le même réseau pour les fonctions 𝑓(𝑥) = 𝑐𝑜𝑠(𝑥) sur le même
intervalle.
10. Remplacer la fonction d’activation tanh par une autre fonction proposée
dans le cours. Quelles lignes du code doivent changer ?
Chapitre 12

TP 1 : Manipulation de
données et validation
croisée - Corrigé

On considère le jeu de données airquality.

data(airquality)

12.1 Manipulation de données

1. Stocker le jeu de données dans un objet de type tibble et afficher les cinq
premières lignes à l’aide de la fonction slice()

airquality <- as_tibble(airquality)

airquality %>% slice(n=1:5)

## # A tibble: 5 x 6
## Ozone Solar.R Wind Temp Month Day
## <int> <int> <dbl> <int> <int> <int>
## 1 41 190 7.4 67 5 1
## 2 36 118 8 72 5 2
## 3 12 149 12.6 74 5 3
## 4 18 313 11.5 62 5 4
## 5 NA NA 14.3 56 5 5

2. Afficher la première ligne de chaque mois grâce aux fonctions group_by()

et slice()

79
80CHAPITRE 12. TP 1 : MANIPULATION DE DONNÉES ET VALIDATION CROISÉE - CORRIGÉ

airquality %>% group_by(Month) %>%

slice(n=1)

## # A tibble: 5 x 6
## # Groups: Month [5]
## Ozone Solar.R Wind Temp Month Day
## <int> <int> <dbl> <int> <int> <int>
## 1 41 190 7.4 67 5 1
## 2 NA 286 8.6 78 6 1
## 3 135 269 4.1 84 7 1
## 4 39 83 6.9 81 8 1
## 5 96 167 6.9 91 9 1

3. Supprimer les lignes ayant ayant au moins une donnée manquante

airquality %>% apply(1,sum) %>%

[Link]() -> containsNA
airquality <- airquality %>% filter(containsNA==FALSE)

## ou drop_na()

4. A l’aide de la fonction summarise, déterminer la mediane du vent, puis,

en ajoutant la fonction group_by(), la médiane du vent par mois.

airquality %>% summarise(Wind_median=median(Wind))

## # A tibble: 1 x 1
## Wind_median
## <dbl>
## 1 9.7
airquality %>% group_by(Month) %>%
summarise(Wind_median_bymonth=median(Wind))

## `summarise()` ungrouping output (override with `.groups` argument)

## # A tibble: 5 x 2
## Month Wind_median_bymonth
## <int> <dbl>
## 1 5 11.5
## 2 6 11.5
## 3 7 7.7
## 4 8 9.7
## 5 9 10.3

5. A l’aide des fonctions filter et select, afficher le taux d’ozone et la vitesse

du vent des jours ayant une température d’au moins 90.
12.2. APPRENTISSAGE POUR PRÉDIRE LE TAUX D’OZONE 81

airquality %>% filter(Temp>=90) %>%

select(Ozone,Wind)

## # A tibble: 13 x 2
## Ozone Wind
## <int> <dbl>
## 1 71 13.8
## 2 97 6.3
## 3 97 5.7
## 4 89 10.3
## 5 110 8
## 6 76 9.7
## 7 118 2.3
## 8 84 6.3
## 9 85 6.3
## 10 96 6.9
## 11 78 5.1
## 12 73 2.8
## 13 91 4.6

6. A l’aide de la fonction mutate(), ajouter une variable high qui vaut 1

pour les jours ayant un taux d’ozone d’au moins 60, et 0 sinon.
airquality <- airquality %>% mutate(high=(Ozone>=60)*1)
airquality

## # A tibble: 111 x 7
## Ozone Solar.R Wind Temp Month Day high
## <int> <int> <dbl> <int> <int> <int> <dbl>
## 1 41 190 7.4 67 5 1 0
## 2 36 118 8 72 5 2 0
## 3 12 149 12.6 74 5 3 0
## 4 18 313 11.5 62 5 4 0
## 5 23 299 8.6 65 5 7 0
## 6 19 99 13.8 59 5 8 0
## 7 8 19 20.1 61 5 9 0
## 8 16 256 9.7 69 5 12 0
## 9 11 290 9.2 66 5 13 0
## 10 14 274 10.9 68 5 14 0
## # ... with 101 more rows

12.2 Apprentissage pour prédire le taux d’ozone

7. Séparer le jeu de données en un jeu d’apprentissage et un jeu test selon
des proportions 2/3 1/3.
82CHAPITRE 12. TP 1 : MANIPULATION DE DONNÉES ET VALIDATION CROISÉE - CORRIGÉ

learningset <- rbinom(dim(airquality)[1],1,.667)

learningdata <- airquality %>% filter(learningset==1)
testdata <- airquality %>% filter(learningset==0)

#ou utiliser sample_frac()

8. On cherche à prédire le taux d’ozone à l’aide d’un modèle linéaire gaussien

et comparant les modèles
— 𝑀0 : moyenne seule
— 𝑀1 : Température
— 𝑀2 : Température et vent
— 𝑀3 : Température, vent et [Link]
— 𝑀4 : Température, vent, [Link] et mois
Réaliser cette tâche avec pour critère l’erreur quadratique moyenne et en
opérant le choix de modèle par validation croisée.
nfold <- 10
folds <- 1:dim(learningdata)[1] %% nfold #0,1,...,9,0,...9,0,... jusqu'à avoir num
folds <- folds + 1 #pour avoir des numéros entre 1 et 10 (optionel)

#affectation des individus dans les folds et ajout de l'information à learningdata

learningdata <- learningdata %>% add_column(fold = sample(folds))

learningerrors <- tibble(k0=rep(NA,dim(learningdata)[1]),k1=k0,k2=k0,k3=k0,k4=k0) #cont

for (i in 1:nfold){

ldata <- learningdata %>% filter(fold!=i) #new learningdata: all folds but i
tdata <- learningdata %>% filter(fold==i) #new test data: fold i

learningerrors$k0[learningdata$fold==i] <- (mean(ldata$Ozone)-tdata$Ozone)^2

model1 <- lm(Ozone~Temp,data=ldata)

tpredict <- predict(model1,newdata=tdata,type="response")
learningerrors$k1[learningdata$fold==i] <- (tpredict-tdata$Ozone)^2

model2 <- lm(Ozone~Temp+Wind,data=ldata)

tpredict <- predict(model2,newdata=tdata,type="response")
learningerrors$k2[learningdata$fold==i] <- (tpredict-tdata$Ozone)^2

model3 <- lm(Ozone~ Temp+Wind+Solar.R,data=ldata)

tpredict <- predict(model3,newdata=tdata,type="response")
learningerrors$k3[learningdata$fold==i] <- (tpredict-tdata$Ozone)^2

model4 <- lm(Ozone~Temp+Wind+Solar.R+Month,data=ldata)

12.2. APPRENTISSAGE POUR PRÉDIRE LE TAUX D’OZONE 83

tpredict <- predict(model4,newdata=tdata,type="response")

learningerrors$k4[learningdata$fold==i] <- (tpredict-tdata$Ozone)^2

meanerror <- learningerrors %>% summarise_all(mean)

meanerror

## # A tibble: 1 x 5
## k0 k1 k2 k3 k4
## <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 1041. 464. 410. 401. 383.
Au vu de l’erreur quadratique par validation croisée, on choisit le
modèle le plus complet
Comment évaluer l’erreur quadratique moyenne de la méthode choisie ?
** En l’évaluant sur le jeu test**
finalmodel <- lm(Ozone~Temp+Wind+Solar.R+Month,data=learningdata)
testpredict <- predict(finalmodel,newdata=testdata,type="response")
mean((testpredict-testdata$Ozone)^2)

## [1] 588.5533
Sa racine carrée est plus facilement interprétable, car dans la bonne unité de
mesure
sqrt(mean((testpredict-testdata$Ozone)^2))

## [1] 24.26012

9. Reprendre les questions précédentes pour prédire la variable ‘high’.

Il suffit de reprendre les codes précédents en remplçant glm par lm et Ozone par
high
84CHAPITRE 12. TP 1 : MANIPULATION DE DONNÉES ET VALIDATION CROISÉE - CORRIGÉ
Chapitre 13

TP2 - Méthodes d’arbres -

Corrigé

Les questions ci-dessous peuvent être traités soit méthode par méthode avec les
packages adaptés (rpart pour l’algorithme CART, ranger ou randomForest pour
les forêts aléatoires), soit de façon unifiée avec le package caret (se baser sur
la page [Link] à
adapter à la méthode utilisée).

1. Récupérer le jeu de données [Link] disponible sur Moodle ou dans

Kaggle ([Link]
heart-attack-possibility). Le séparer en jeu de données/d’apprentissage .

library(tidyverse)
library(caret)
library(rpart)
library(randomForest)
library([Link])

heartdata <- [Link]("data/[Link]")

heartdata <- as_tibble(heartdata)

#pour la suite, il faut que target soit un facteur pour que caret comprenne qu'on fait de la clas
heartdata <- heartdata %>% mutate(target=[Link](ifelse(target==0,"no","yes")))

inTrain <- createDataPartition( #fonction de caret qui sélectionne les indices des individus à

85
86 CHAPITRE 13. TP2 - MÉTHODES D’ARBRES - CORRIGÉ

y = heartdata$target,
p = .75,
list = FALSE
)
#dans l'aide de createDataPartition, on remarquera qu'on peut de même créer des échanti

hearttraining <- heartdata %>% slice(n=inTrain)

hearttest <- heartdata %>% slice(n=-inTrain)

13.1 CART

2. Apprendre un arbre de classification pour la prédiction des individus à

risque. Le représenter.

Règlement des paramètres de comparaison des méthodes

ctrl <- trainControl(
#on va réaliser de validation croisées à 10 fold, et ce 3 fois pour diminuer l'influe
method = "repeatedcv",
number=10,
repeats = 3,
#pour comparer les méthodes, on peut choisir la métrique ROC (=classer les individus
classProbs = TRUE,
summaryFunction = twoClassSummary
)

Apprentissage
cartFit <- train(
target ~ .,
data = hearttraining,
method = "rpart",
tuneLength = 15, #donne le nombre de valeurs à essayer pour chaque paramètre à fare v
trControl = ctrl,
metric = "ROC"
)

plot(cartFit)
13.1. CART 87

0.80
ROC (Repeated Cross−Validation)

0.75

0.70

0.65

0.60

0.0 0.1 0.2 0.3 0.4 0.5

Complexity Parameter
Le modèle ayant la meilleure prédiction par validation croisée est celui pour
cp=0, c’est-à-dire aucune pénalisation

Le modèle retenu est alors sous finalModel dans la sortie

decisiontree <- cartFit$finalModel
plot(decisiontree)
text(decisiontree)
cp< 0.5
|

ca>=0.5 thal>=2.5
exang>=0.5 oldpeak>=0.9
no yes
oldpeak>=0.7 thal>=2.5 no yes

yes no yes
no
ou, pour obtenir un meilleur rendu (en utilisant le package [Link])
[Link](decisiontree)
88 CHAPITRE 13. TP2 - MÉTHODES D’ARBRES - CORRIGÉ

yes
0.54
100%
yes cp < 1 no

no yes
0.27 0.80
49% 51%
ca >= 1 thal >= 3
yes yes
0.54 0.54
22% 11%
exang = 1 oldpeak >= 0.9

no yes
0.26 0.78
10% 12%
oldpeak >= 0.7 thal >= 3

no no yes no yes no yes yes

0.05 0.06 0.71 0.43 0.90 0.36 0.75 0.88
27% 7% 3% 3% 9% 6% 5% 40%

Pour finir, regardons les performances de l’arbre ainsi appris sur le jeu test
cartPred <- predict(cartFit,hearttest)
# avec option type="prob" si on veut les probs d'appartenance. Ici, la classe de plus g
confusionMatrix(data=cartPred,hearttest$target)

## Confusion Matrix and Statistics

##
## Reference
## Prediction no yes
## no 24 6
## yes 10 35
##
## Accuracy : 0.7867
## 95% CI : (0.6768, 0.8729)
## No Information Rate : 0.5467
## P-Value [Acc > NIR] : 1.324e-05
##
## Kappa : 0.5652
##
## Mcnemar's Test P-Value : 0.4533
##
## Sensitivity : 0.7059
## Specificity : 0.8537
## Pos Pred Value : 0.8000
## Neg Pred Value : 0.7778
13.2. FORÊTS ALÉATOIRES 89

## Prevalence : 0.4533
## Detection Rate : 0.3200
## Detection Prevalence : 0.4000
## Balanced Accuracy : 0.7798
##
## 'Positive' Class : no
##

3. Relancer plusieurs fois le codes des questions précédentes et comparer les

arbres. Commenter.

On observe la construction à chaque fois d’un arbre différent. Le caractère aléa-

toire de la séparation apprentissage/test suffit à perturber le résultat, ce qui rend
difficile l’acceptation d’un arbre particulier comme outil de diagnostic.

13.2 Forêts aléatoires

4. Reprendre les questions précédentes à l’aide de forêts aléatoires. Com-
menter.

Règlement des paramètres de comparaison des méthodes : on pourrait reprendre

les réglages utilisés pour Cart, à savoir une validation croisée multiple. On peut
également dans le cadre des forêts aléatoires utiliser l’erreur Out-of-bag pour
éviter de redécouper le jeu de données
ctrl <- trainControl(
#on va réaliser de validation croisées à 10 fold, et ce 3 fois pour diminuer l'influence de la
method = "oob",
#method="repeatedcv",
#number=10,
#repeats = 3,
#pour comparer les méthodes, on peut choisir la métrique ROC (=classer les individus dans le bo
classProbs = TRUE,
summaryFunction = twoClassSummary
)

## Warning: Custom summary measures cannot be computed for out-of-baf resampling.

## This value of `summaryFunction` will be ignored.
Apprentissage
rfFit <- train(
target ~ .,
data = hearttraining,
method = "rf",
tuneLength = 15, #donne le nombre de valeurs à essayer pour chaque paramètre à fare varier (ici
90 CHAPITRE 13. TP2 - MÉTHODES D’ARBRES - CORRIGÉ

trControl = ctrl,
metric = "ROC"
)

## note: only 12 unique complexity parameters in default grid. Truncating the grid to 1
## Warning in [Link](x, y, weights = w, ...): The metric "ROC" was not in
## the result set. Accuracy will be used instead.
plot(rfFit)
Accuracy Out of Bag Resampling

0.835

0.830

0.825

0.820

0.815

2 4 6 8 10 12

#Randomly Selected Predictors

Regardons les performances de l’arbre ainsi appris sur le jeu test

cartPred <- predict(cartFit,hearttest)
# avec option type="prob" si on veut les probs d'appartenance. Ici, la classe de plus g
confusionMatrix(data=cartPred,hearttest$target)

## Confusion Matrix and Statistics

##
## Reference
## Prediction no yes
## no 24 6
## yes 10 35
##
## Accuracy : 0.7867
## 95% CI : (0.6768, 0.8729)
## No Information Rate : 0.5467
## P-Value [Acc > NIR] : 1.324e-05
13.2. FORÊTS ALÉATOIRES 91

##
## Kappa : 0.5652
##
## Mcnemar's Test P-Value : 0.4533
##
## Sensitivity : 0.7059
## Specificity : 0.8537
## Pos Pred Value : 0.8000
## Neg Pred Value : 0.7778
## Prevalence : 0.4533
## Detection Rate : 0.3200
## Detection Prevalence : 0.4000
## Balanced Accuracy : 0.7798
##
## 'Positive' Class : no
##

5. Quelles sont les variables les plus importantes pour la prédiction du risque
cardio-vasculaire ?

varImp(rfFit)

## rf variable importance
##
## Overall
## thalach 100.00
## ca 91.22
## cp 83.05
## oldpeak 79.63
## thal 70.39
## age 62.67
## chol 53.98
## trestbps 46.92
## exang 46.39
## slope 25.79
## sex 20.29
## restecg 10.35
## fbs 0.00
Les détails sur la détermination de ces coefficients sont donnée sur [Link]
.[Link]/caret/[Link] (première entrée pour une recherche
“caret variable importance”). Pour le cas d’arbres de classification, elles sont
déterminées comme vu en cours (différence de prédiction entre version réelle et
permutée de la variable d’intérêt, normalisée par l’écart-type puis modifiée pour
que la variable la plus importante soit à 100).
Interprétation : si thalach a un indice d’importance de 100, l’âge en a un de
92 CHAPITRE 13. TP2 - MÉTHODES D’ARBRES - CORRIGÉ

56
La version non ramenée à un maximum de 100 peut s’obtenir
varImp(rfFit,scale=FALSE)

## rf variable importance
##
## Overall
## thalach 14.402
## ca 13.241
## cp 12.163
## oldpeak 11.711
## thal 10.490
## age 9.470
## chol 8.322
## trestbps 7.390
## exang 7.319
## slope 4.598
## sex 3.871
## restecg 2.558
## fbs 1.191
Interpretation : Considérons trois jeux de données 𝐽1 , 𝐽2 , 𝐽3 , thalach étant
prise en compte dans 𝐽3 mais pas dans les deux autres. Le gain en terme de
critère (ici Accuracy) entre 𝐽1 et 𝐽3 est en moyenne 14 fois plus grand que la
différence entre 𝐽1 et 𝐽2 .
Chapitre 14

TP3 - Modèles linéaires

pénalisés - Corrigé

14.1 Avec glmnet

1. Récupérer les données [Link] disponibles sur Moodle. Elles sont issues
du package [Link] mais modifiées pour supprimer les gènes appa-
raissant en double dans les données initiales. Elles comprennent la mesure
de l’expression d’un peu moins de 2000 gènes sur 62 échantillons de tissus
du colon, ainsi que de l’information concernant le statut tumoral ou non
dudit tissu.

library(tidyverse)
library(caret)
library(glmnet)

colondata <- read.csv2("data/[Link]")

colondata <- as_tibble(colondata)

#pour la suite, il faut que tumoral soit un facteur pour que caret comprenne qu'on fait de la cla
colondata <- colondata %>% mutate(tumoral=[Link](ifelse(tumoral==0,"no","yes")))

inTrain <- createDataPartition( #fonction de caret qui sélectionne les indices des individus à
y = colondata$tumoral,
p = .75,

93
94 CHAPITRE 14. TP3 - MODÈLES LINÉAIRES PÉNALISÉS - CORRIGÉ

list = FALSE
)
#dans l'aide de createDataPartition, on remarquera qu'on peut de même créer des échanti

colontrain <- colondata %>% slice(n=inTrain)

colontest <- colondata %>% slice(n=-inTrain)

2. Peut-on mettre en place une règle de prédiction du statut tumoral à l’aide

de le régression logistique standard (fonction glm) ? Commenter.

model <- glm(tumoral~.,data=colontrain,family = binomial(link = "logit"))

predictions <- predict(model,newdata = colontest,type="response")

## Warning in [Link](object, newdata, [Link], scale = 1, type = if (type == :

## prediction from a rank-deficient fit may be misleading
confusionMatrix(data=as_factor(round(predictions)),as_factor((colontest$tumoral=="yes")

## Confusion Matrix and Statistics

##
## Reference
## Prediction 0 1
## 0 2 3
## 1 3 7
##
## Accuracy : 0.6
## 95% CI : (0.3229, 0.8366)
## No Information Rate : 0.6667
## P-Value [Acc > NIR] : 0.797
##
## Kappa : 0.1
##
## Mcnemar's Test P-Value : 1.000
##
## Sensitivity : 0.4000
## Specificity : 0.7000
## Pos Pred Value : 0.4000
## Neg Pred Value : 0.7000
## Prevalence : 0.3333
## Detection Rate : 0.1333
## Detection Prevalence : 0.3333
## Balanced Accuracy : 0.5500
##
## 'Positive' Class : 0
##
On constate que l’algorithme de maximistion de la vraisemblance converge mais
14.1. AVEC GLMNET 95

vers une solution qui est mauvaise, ce qu’indique d’ailleurs le message d’aver-
tissement. Ceci est dû au fait que le problème est en grande dimension (1911
variables pour àun peu plus de quarante observations dans l’ensemble d’appren-
tissage). Il faut donc également recourir à la sélection de variables.

3. Mettre en place, grâce au package glmnet, une régression ridge et tracer

le graphe de l’évolution des coefficients en fonction de la pénalité 𝑙𝑎𝑚𝑏𝑑𝑎.

Faire de même avec une régression lasso et une régression elastic-net de para-
mètre 𝛼 = .5. Comparer les différents graphes et commenter.
[Link] <- colontrain %>% select(tumoral) %>% [Link]()
[Link] <- colontrain %>% select(-tumoral) %>% [Link]()
[Link] <- glmnet([Link],[Link],family = "binomial",alpha=0)
plot([Link])

1911 1911 1911 1911

2e−04
Coefficients

−2e−04
−6e−04

0.00 0.02 0.04 0.06

L1 Norm
[Link] <- glmnet([Link],[Link],family = "binomial",alpha=1)
plot([Link])
96 CHAPITRE 14. TP3 - MODÈLES LINÉAIRES PÉNALISÉS - CORRIGÉ

0 14 17 23 23 26

0.010
Coefficients

0.000
−0.010

0.00 0.02 0.04 0.06 0.08 0.10

L1 Norm
[Link] <- glmnet([Link],[Link],family = "binomial",alpha=0.5)
plot([Link])

0 34 47 55 65 79 83 91
0.010
0.005
Coefficients

0.000
−0.005

0.00 0.02 0.04 0.06 0.08 0.10 0.12 0.14

L1 Norm

On constate, pour la pénalité ridge, un faisceau qui illustre bien la prise en

compte de la colinéarité (les trajectoires se croisent peu quand 𝜆 évolue) mais une
absence de sélection puisque toutes les variables ont dès le départ des coeeficients
non nuls. Pour Lasso, on voit bien les variables “s’allumer” les unes après les
autres, permettant de faire de la sélection, mais les trajectoires croisées rendent
14.1. AVEC GLMNET 97

les interprétations difficiles. Elastic-Net offre un compromis entre les deux.

4. On décide pour le moment de choisir la méthode lasso. Opérer le choix

de 𝜆.

a. Par validation croisée (fonction [Link])

[Link] <- [Link]([Link],[Link],nfolds=5,family="binomial")

[Link]$[Link]

## [1] 0.07565021
[Link] <- glmnet([Link],[Link],family="binomial",alpha=1,nlambda=1,lambda=[Link]$lamb

[Link] <- colontest %>% select(tumoral) %>% [Link]()

[Link] <- colontest %>% select(-tumoral) %>% [Link]()
[Link] <- predict([Link],[Link],type="response",family="binomial")
results <- tibble(proba=[Link],MAP=round([Link]),truth=([Link]=="ye
results

## # A tibble: 15 x 3
## proba[,"s0"] MAP[,"s0"] truth[,"tumoral"]
## <dbl> <dbl> <dbl>
## 1 0.107 0 0
## 2 0.979 1 1
## 3 0.995 1 1
## 4 0.666 1 1
## 5 0.818 1 1
## 6 0.859 1 1
## 7 0.174 0 0
## 8 0.867 1 1
## 9 0.419 0 0
## 10 0.118 0 1
## 11 0.970 1 1
## 12 0.139 0 0
## 13 0.829 1 0
## 14 0.680 1 1
## 15 0.903 1 1
confusionMatrix(data=as_factor(results$MAP),as_factor(results$truth))

## Confusion Matrix and Statistics

##
## Reference
## Prediction 0 1
## 0 4 1
## 1 1 9
##
98 CHAPITRE 14. TP3 - MODÈLES LINÉAIRES PÉNALISÉS - CORRIGÉ

## Accuracy : 0.8667
## 95% CI : (0.5954, 0.9834)
## No Information Rate : 0.6667
## P-Value [Acc > NIR] : 0.07936
##
## Kappa : 0.7
##
## Mcnemar's Test P-Value : 1.00000
##
## Sensitivity : 0.8000
## Specificity : 0.9000
## Pos Pred Value : 0.8000
## Neg Pred Value : 0.9000
## Prevalence : 0.3333
## Detection Rate : 0.2667
## Detection Prevalence : 0.3333
## Balanced Accuracy : 0.8500
##
## 'Positive' Class : 0
##

b. Par stability selection

*On lance 𝐵 bootstrap, on apprend sur chacun d’eux un modèle lasso avec trop
de gènes (en divisant par exemple le 𝑙𝑎𝑚𝑏𝑑𝑎 selectionné par validation croisée
par 2) et on regarde quels sont les gènes les plus fréquemment sélectionnés).
B=100 # nombre de bootstraps
npatients <- dim([Link])[1]
selected <- rep(0,dim([Link])[2]) # comptage du nombre de fois où chaque gène est séle
for (b in 1:B){
#echantillon bootstrap
bootsample <- sample(1:npatients,npatients,replace=TRUE)
[Link] <- [Link][bootsample,]
[Link] <- [Link][bootsample,]
#apprentissage
[Link] <- glmnet([Link],[Link],family="binomial",alpha=1,nlambda=1,lambda=.
#recuperation des identites des coefficients non nuls
selectedgenes <- [Link]$beta@i
for (i in selectedgenes){
selected[i] <- selected[i] +1
}
}

#restriction du jeu d'apprentissage aux genes étant sélectionnés au moins 1/4 du temps
selection <- which(selected>B/4)
14.1. AVEC GLMNET 99

[Link] <- [Link]([Link][,selection])

[Link] <- [Link] %>% add_column(tumoral=([Link]=="yes")*1)

# apprentissage suivant un modèle linéaire classique

model <- glm(tumoral~.,data=[Link],family = binomial(link = "logit"))

## Warning: [Link]: algorithm did not converge

## Warning: [Link]: fitted probabilities numerically 0 or 1 occurred
predictions <- predict(model,newdata = colontest,type="response")
confusionMatrix(data=as_factor(round(predictions)),as_factor((colontest$tumoral=="yes")*1))

## Confusion Matrix and Statistics

##
## Reference
## Prediction 0 1
## 0 2 1
## 1 3 9
##
## Accuracy : 0.7333
## 95% CI : (0.449, 0.9221)
## No Information Rate : 0.6667
## P-Value [Acc > NIR] : 0.4041
##
## Kappa : 0.3333
##
## Mcnemar's Test P-Value : 0.6171
##
## Sensitivity : 0.4000
## Specificity : 0.9000
## Pos Pred Value : 0.6667
## Neg Pred Value : 0.7500
## Prevalence : 0.3333
## Detection Rate : 0.1333
## Detection Prevalence : 0.2000
## Balanced Accuracy : 0.6500
##
## 'Positive' Class : 0
##
Evaluer la qualité des modèles retenus sur l’échantillon test.
Dans ce cas, la méthode choisie par validation croisée semble être meilleure

5. Quel autre paramètre pourrait-on régler par validation croisée afin d’élar-
gir la famille de modèles considérés ?
100CHAPITRE 14. TP3 - MODÈLES LINÉAIRES PÉNALISÉS - CORRIGÉ

On pourrait remplacer la pénalité Lasso par une pénalité Elastic-Net et choisir

𝛼 par validation croisée.

14.2 Avec caret

6. Reprendre le jeu de données [Link] disponible sur Moodle ou
dans Kaggle ([Link]
set-on-heart-attack-possibility). Traiter à l’aide du package caret
l’apprentissage de la variable target à l’aide de la méthode glmnet.

heartdata <- [Link]("data/[Link]")

heartdata <- as_tibble(heartdata)

#pour la suite, il faut que target soit un facteur pour que caret comprenne qu'on fait
heartdata <- heartdata %>% mutate(target=[Link](ifelse(target==0,"no","yes")))

inTrain <- createDataPartition( #fonction de caret qui sélectionne les indices des in
y = heartdata$target,
p = .75,
list = FALSE
)
#dans l'aide de createDataPartition, on remarquera qu'on peut de même créer des échanti

hearttraining <- heartdata %>% slice(n=inTrain)

hearttest <- heartdata %>% slice(n=-inTrain)
ctrl <- trainControl(
#on va réaliser de validation croisées à 10 fold, et ce 3 fois pour diminuer l'influe
method = "repeatedcv",
number=10,
repeats = 3,
#pour comparer les méthodes, on peut choisir la métrique ROC (=classer les individus
classProbs = TRUE,
summaryFunction = twoClassSummary
)
glmFit <- train(
target ~ .,
data = hearttraining,
method = "glmnet",
tuneLength = 15, #donne le nombre de valeurs à essayer pour chaque paramètre à fare v
14.2. AVEC CARET 101

trControl = ctrl,
metric = "ROC"
)

plot(glmFit)

Regularization Parameter
0.00263001563835564 0.0263001563835564
0.0046769026577682 0.046769026577682
0.00831683969906551 0.0831683969906551
0.0147896647934425 0.147896647934425
ROC (Repeated Cross−Validation)

0.9

0.8

0.7

0.6

0.5

0.2 0.4 0.6 0.8 1.0

Mixing Percentage
Les différentes couleurs correspondent à des valeurs différentes de 𝜆, l’abscisse
au coefficient 𝛼
plot(glmFit$finalModel)
102CHAPITRE 14. TP3 - MODÈLES LINÉAIRES PÉNALISÉS - CORRIGÉ

0 11 13 13

1.0
0.5
Coefficients

0.0
−0.5
−1.0
−1.5

0 2 4 6

L1 Norm
glmPred <- predict(glmFit,hearttest)
# avec option type="prob" si on veut les probs d'appartenance. Ici, la classe de plus g
confusionMatrix(data=glmPred,hearttest$target)

## Confusion Matrix and Statistics

##
## Reference
## Prediction no yes
## no 26 4
## yes 8 37
##
## Accuracy : 0.84
## 95% CI : (0.7372, 0.9145)
## No Information Rate : 0.5467
## P-Value [Acc > NIR] : 7.56e-08
##
## Kappa : 0.6739
##
## Mcnemar's Test P-Value : 0.3865
##
## Sensitivity : 0.7647
## Specificity : 0.9024
## Pos Pred Value : 0.8667
## Neg Pred Value : 0.8222
## Prevalence : 0.4533
## Detection Rate : 0.3467
## Detection Prevalence : 0.4000
14.2. AVEC CARET 103

## Balanced Accuracy : 0.8336

##
## 'Positive' Class : no
##
104CHAPITRE 14. TP3 - MODÈLES LINÉAIRES PÉNALISÉS - CORRIGÉ
Chapitre 15

TP4 - SVM - Corrigé

15.1 Avec le package e1071

library(tidyverse)
library(caret)
library(e1071)
library(kernlab)

1. Charger le jeu de données iris, introduire une variable binaire à prédire

qui indique qu’une fleur est de l’espèce virginica ou non, et restreindre
le jeu de données aux variables concernant les pétales et cette variable à
prédire. Séparer également le jeu en apprentissage/test.

data(iris)
irisdata <- as_tibble(iris)

#pour la suite, il faut que target soit un facteur pour que caret comprenne qu'on fait de la clas
irisdata <- irisdata %>% mutate(target=[Link](ifelse(Species=="virginica","yes","no"))) %>%
#puis on sélectionne les variables demandées
select(c([Link],[Link],target))

inTrain <- createDataPartition( #fonction de caret qui sélectionne les indices des individus à
y = irisdata$target,
p = .75,
list = FALSE
)
#dans l'aide de createDataPartition, on remarquera qu'on peut de même créer des échantillons boot

105
106 CHAPITRE 15. TP4 - SVM - CORRIGÉ

iristraining <- irisdata %>% slice(n=inTrain)

iristest <- irisdata %>% slice(n=-inTrain)
pl <- ggplot(iristraining,aes(x=[Link],y=[Link],color=target)) + geom_point(
pl

6
[Link]

target
4
no
yes

0.0 0.5 1.0 1.5 2.0 2.5

[Link]

2. A l’aide de la fonction svm, mettre en place l’apprentissage par la mé-

thode linéaire et par noyau gaussien (avec les valeurs de gamma par dé-
faut). Comparer la qualité des prédictions de ces méthodes sur l’ensemble
de test. Commenter.

#apprentissage des modèles

linearsvm <- svm(formula = target~.,
data = iristraining,
type = 'C-classification',
kernel = 'linear')

gaussiansvm <- svm(formula = target~.,

data = iristraining,
type = 'C-classification',
kernel = 'radial')
#prediction sur le jeu test
linearpred <- predict(linearsvm, newdata = iristest)
gaussianpred <- predict(gaussiansvm, newdata = iristest)
15.1. AVEC LE PACKAGE E1071 107

#matrices de confusion pour le svm linéaire

confusionMatrix(data=linearpred,iristest$target)

## Confusion Matrix and Statistics

##
## Reference
## Prediction no yes
## no 25 1
## yes 0 11
##
## Accuracy : 0.973
## 95% CI : (0.8584, 0.9993)
## No Information Rate : 0.6757
## P-Value [Acc > NIR] : 9.409e-06
##
## Kappa : 0.937
##
## Mcnemar's Test P-Value : 1
##
## Sensitivity : 1.0000
## Specificity : 0.9167
## Pos Pred Value : 0.9615
## Neg Pred Value : 1.0000
## Prevalence : 0.6757
## Detection Rate : 0.6757
## Detection Prevalence : 0.7027
## Balanced Accuracy : 0.9583
##
## 'Positive' Class : no
##
plot(linearsvm,iristest)
108 CHAPITRE 15. TP4 - SVM - CORRIGÉ

SVM classification plot

o
oo o

2.0 o o
oo o

yes
o
[Link]

1.5 oo
o o o
oo o
o
o oo
1.0 oo

no
0.5
oo
oo
oo
o o
2 3 4 5 6

[Link]
confusionMatrix(data=gaussianpred,iristest$target)

## Confusion Matrix and Statistics

##
## Reference
## Prediction no yes
## no 25 1
## yes 0 11
##
## Accuracy : 0.973
## 95% CI : (0.8584, 0.9993)
## No Information Rate : 0.6757
## P-Value [Acc > NIR] : 9.409e-06
##
## Kappa : 0.937
##
## Mcnemar's Test P-Value : 1
##
## Sensitivity : 1.0000
## Specificity : 0.9167
## Pos Pred Value : 0.9615
## Neg Pred Value : 1.0000
## Prevalence : 0.6757
## Detection Rate : 0.6757
## Detection Prevalence : 0.7027
## Balanced Accuracy : 0.9583
15.1. AVEC LE PACKAGE E1071 109

##
## 'Positive' Class : no
##
plot(gaussiansvm,iristest)

SVM classification plot

o
oo o

2.0 o o
oo o

yes
o
[Link]

1.5 oo
o o o
oo o
o
o oo
1.0 oo

no
0.5
oo
oo
xo
o
o o
2 3 4 5 6

[Link]

3. Dans le cas du noyau gaussien, proposer une manière de choisir la valeur

de gamma de façon donnée-dépendante (data-driven) ?

On peut le régler par validation croisée

4. Reprendre les questions 1 et 2 avec l’espèce versicolor

data(iris)
irisdata <- as_tibble(iris)

#pour la suite, il faut que target soit un facteur pour que caret comprenne qu'on fait de la clas
irisdata <- irisdata %>% mutate(target=[Link](ifelse(Species=="versicolor","yes","no"))) %>%
#puis on sélectionne les variables demandées
select(c([Link],[Link],target))

inTrain <- createDataPartition( #fonction de caret qui sélectionne les indices des individus à
y = irisdata$target,
p = .75,
list = FALSE
)
110 CHAPITRE 15. TP4 - SVM - CORRIGÉ

#dans l'aide de createDataPartition, on remarquera qu'on peut de même créer des échanti

iristraining <- irisdata %>% slice(n=inTrain)

iristest <- irisdata %>% slice(n=-inTrain)
pl <- ggplot(iristraining,aes(x=[Link],y=[Link],color=target)) + geom_point(
pl

6
[Link]

target
4 no
yes

0.0 0.5 1.0 1.5 2.0 2.5

[Link]

Cette fois-ci, les données ne sont pas linéairement séparables, la version linéaire
ne devrait pas aussi bien fonctionner.
#apprentissage des modèles
linearsvm <- svm(formula = target~.,
data = iristraining,
type = 'C-classification',
kernel = 'linear')

gaussiansvm <- svm(formula = target~.,

data = iristraining,
type = 'C-classification',
kernel = 'radial')
#prediction sur le jeu test
linearpred <- predict(linearsvm, newdata = iristest)
gaussianpred <- predict(gaussiansvm, newdata = iristest)
15.1. AVEC LE PACKAGE E1071 111

confusionMatrix(data=linearpred,iristest$target)

## Confusion Matrix and Statistics

##
## Reference
## Prediction no yes
## no 25 12
## yes 0 0
##
## Accuracy : 0.6757
## 95% CI : (0.5021, 0.8199)
## No Information Rate : 0.6757
## P-Value [Acc > NIR] : 0.577435
##
## Kappa : 0
##
## Mcnemar's Test P-Value : 0.001496
##
## Sensitivity : 1.0000
## Specificity : 0.0000
## Pos Pred Value : 0.6757
## Neg Pred Value : NaN
## Prevalence : 0.6757
## Detection Rate : 0.6757
## Detection Prevalence : 1.0000
## Balanced Accuracy : 0.5000
##
## 'Positive' Class : no
##
plot(linearsvm,iristest)
112 CHAPITRE 15. TP4 - SVM - CORRIGÉ

SVM classification plot

2.5 o x
o
x
2.0 x

yes
o o
o oo o o
o o
[Link]

o
1.5 o
x
x x
o oxx
x
1.0 o o

no
0.5
o
o
xo
xx
o o
2 3 4 5 6

[Link]
confusionMatrix(data=gaussianpred,iristest$target)

## Confusion Matrix and Statistics

##
## Reference
## Prediction no yes
## no 24 1
## yes 1 11
##
## Accuracy : 0.9459
## 95% CI : (0.8181, 0.9934)
## No Information Rate : 0.6757
## P-Value [Acc > NIR] : 8.637e-05
##
## Kappa : 0.8767
##
## Mcnemar's Test P-Value : 1
##
## Sensitivity : 0.9600
## Specificity : 0.9167
## Pos Pred Value : 0.9600
## Neg Pred Value : 0.9167
## Prevalence : 0.6757
## Detection Rate : 0.6486
## Detection Prevalence : 0.6757
## Balanced Accuracy : 0.9383
15.2. AVEC CARET 113

##
## 'Positive' Class : no
##
plot(gaussiansvm,iristest)

SVM classification plot

2.5 o o
x
o
2.0 o

yes
o o
o xo o o
o o
[Link]

o
1.5 o
o o
o ooo
o
1.0 o o

no
0.5
o
ooo
oo
o o
2 3 4 5 6

[Link]

15.2 Avec caret

6. Reprendre le jeu de données [Link] disponible sur Moodle ou
dans Kaggle ([Link]
set-on-heart-attack-possibility). Traiter à l’aide du package caret
l’apprentissage de la variable target à l’aide d’une méthode SVM.

heartdata <- [Link]("data/[Link]")

heartdata <- as_tibble(heartdata)

#pour la suite, il faut que target soit un facteur pour que caret comprenne qu'on fait de la clas
heartdata <- heartdata %>% mutate(target=[Link](ifelse(target==0,"no","yes")))

inTrain <- createDataPartition( #fonction de caret qui sélectionne les indices des individus à
y = heartdata$target,
p = .75,
list = FALSE
)
114 CHAPITRE 15. TP4 - SVM - CORRIGÉ

#dans l'aide de createDataPartition, on remarquera qu'on peut de même créer des échanti

hearttraining <- heartdata %>% slice(n=inTrain)

hearttest <- heartdata %>% slice(n=-inTrain)
ctrl <- trainControl(
#on va réaliser de validation croisées à 10 fold, et ce 3 fois pour diminuer l'influe
method = "repeatedcv",
number=10,
repeats = 3,
#pour comparer les méthodes, on peut choisir la métrique ROC (=classer les individus
classProbs = TRUE,
summaryFunction = twoClassSummary
)

SVM linéaire
svmLinearFit <- train(
target ~ .,
data = hearttraining,
method = "svmLinear",
#tuneLength = 5, #donne le nombre de valeurs à essayer pour chaque paramètre à fare v
trControl = ctrl,
metric = "ROC",
preProcess = c("center","scale"),
tuneGrid = [Link](C = seq(0.1, 2, length = 19))
)
plot(svmLinearFit)
15.2. AVEC CARET 115
ROC (Repeated Cross−Validation)

0.900

0.899

0.898

0.897

0.5 1.0 1.5 2.0

Cost
svmLinearFit

## Support Vector Machines with Linear Kernel

##
## 228 samples
## 13 predictor
## 2 classes: 'no', 'yes'
##
## Pre-processing: centered (13), scaled (13)
## Resampling: Cross-Validated (10 fold, repeated 3 times)
## Summary of sample sizes: 205, 206, 205, 206, 206, 204, ...
## Resampling results across tuning parameters:
##
## C ROC Sens Spec
## 0.1000000 0.8965987 0.7396970 0.8903846
## 0.2055556 0.8982090 0.7460606 0.9038462
## 0.3111111 0.8998271 0.7460606 0.9008547
## 0.4166667 0.8999864 0.7493939 0.8985043
## 0.5222222 0.8994095 0.7457576 0.9014957
## 0.6277778 0.9004079 0.7618182 0.9010684
## 0.7333333 0.9001748 0.7557576 0.9089744
## 0.8388889 0.9006605 0.7490909 0.9117521
## 0.9444444 0.8998912 0.7557576 0.9061966
## 1.0500000 0.8993570 0.7400000 0.9089744
## 1.1555556 0.8985451 0.7457576 0.9087607
## 1.2611111 0.8987549 0.7554545 0.9145299
## 1.3666667 0.8987549 0.7554545 0.9089744
116 CHAPITRE 15. TP4 - SVM - CORRIGÉ

## 1.4722222 0.8990113 0.7457576 0.9061966

## 1.5777778 0.8988228 0.7493939 0.9061966
## 1.6833333 0.8988228 0.7424242 0.9036325
## 1.7888889 0.8988228 0.7490909 0.9089744
## 1.8944444 0.8991006 0.7524242 0.9034188
## 2.0000000 0.8993337 0.7490909 0.9036325
##
## ROC was used to select the optimal model using the largest value.
## The final value used for the model was C = 0.8388889.
SVM gaussien
svmRadialFit <- train(
target ~ .,
data = hearttraining,
method = "svmRadial",
tuneLength = 15, #donne le nombre de valeurs à essayer pour chaque paramètre à fare v
trControl = ctrl,
metric = "ROC",
preProcess = c("center","scale")
)

Le meilleur réglage des paramètres est

svmRadialFit$bestTune

## sigma C
## 1 0.05160797 0.25
svmRadialFit

## Support Vector Machines with Radial Basis Function Kernel

##
## 228 samples
## 13 predictor
## 2 classes: 'no', 'yes'
##
## Pre-processing: centered (13), scaled (13)
## Resampling: Cross-Validated (10 fold, repeated 3 times)
## Summary of sample sizes: 205, 206, 205, 206, 206, 205, ...
## Resampling results across tuning parameters:
##
## C ROC Sens Spec
## 0.25 0.9049126 0.7809091 0.8448718
## 0.50 0.9014724 0.7584848 0.8692308
## 1.00 0.8995921 0.7518182 0.8833333
## 2.00 0.8993046 0.7803030 0.8724359
## 4.00 0.8988287 0.7896970 0.8514957
## 8.00 0.8867055 0.7772727 0.8224359
15.2. AVEC CARET 117

## 16.00 0.8749961 0.7584848 0.8115385

## 32.00 0.8724165 0.7424242 0.7931624
## 64.00 0.8691977 0.7400000 0.7985043
## 128.00 0.8691977 0.7457576 0.7987179
## 256.00 0.8691977 0.7490909 0.7931624
## 512.00 0.8691977 0.7490909 0.7931624
## 1024.00 0.8691977 0.7487879 0.7933761
## 2048.00 0.8691977 0.7484848 0.7876068
## 4096.00 0.8691977 0.7460606 0.7961538
##
## Tuning parameter 'sigma' was held constant at a value of 0.05160797
## ROC was used to select the optimal model using the largest value.
## The final values used for the model were sigma = 0.05160797 and C = 0.25.
Evaluation sur le jeu test
On choisit le meilleur des deux modèles au vu des validations croisées. Si c’est
le modèle radial qui est choisi
#prediction sur le jeu test
radialpred <- predict(svmRadialFit, newdata = hearttest)

#matrices de confusion pour le svm linéaire

confusionMatrix(data=radialpred,hearttest$target)

## Confusion Matrix and Statistics

##
## Reference
## Prediction no yes
## no 26 5
## yes 8 36
##
## Accuracy : 0.8267
## 95% CI : (0.7219, 0.9043)
## No Information Rate : 0.5467
## P-Value [Acc > NIR] : 3.126e-07
##
## Kappa : 0.6476
##
## Mcnemar's Test P-Value : 0.5791
##
## Sensitivity : 0.7647
## Specificity : 0.8780
## Pos Pred Value : 0.8387
## Neg Pred Value : 0.8182
## Prevalence : 0.4533
## Detection Rate : 0.3467
## Detection Prevalence : 0.4133
118 CHAPITRE 15. TP4 - SVM - CORRIGÉ

## Balanced Accuracy : 0.8214

##
## 'Positive' Class : no
##
Chapitre 16

TP5 - Réseaux de neurones

- Corrigé

16.1 Exercice 1

Considérons la fonction binaire XOR(𝑥1 , 𝑥2 ) du OU exclusif entre deux variables

binaires : XOR prend la valeur 1 si et seulement si l’un des variables vaut 0 et
l’autre 1.

1. Montrer qu’il n’est pas possible de définir cette fonction à partir d’un
modèle linéaire.

Supposons qu’il existe (𝛼, 𝛽, 𝛾) tels que

𝑋𝑂𝑅(𝑥1 , 𝑥2 ) = 𝛼𝑥1 + 𝛽𝑥2 + 𝛾

Alors

𝛾 = 0 pour 𝑥1 = 0, 𝑥2 = 0
𝛼 + 𝛾 = 1 pour 𝑥1 = 1, 𝑥2 = 0
𝛽 + 𝛾 = 2 pour 𝑥1 = 0, 𝑥2 = 1
𝛼 + 𝛽 + 𝛾 = 0 pour 𝑥1 = 1, 𝑥2 = 1

ce qui est impossible.

119
120 CHAPITRE 16. TP5 - RÉSEAUX DE NEURONES - CORRIGÉ

2. Montrer qu’il est existe de multiples façon d’y arriver à l’aide du réseau
de neurones suivant

x1

x2

1 −1 1
Une solution possible est 𝑊 [1] = ( ) et 𝑊 [2] = ( ).
−1 1 1
1
𝑘 −𝑘
Tout choix de la forme 𝑊 [1] = ( ) et 𝑊 [2] = ( 𝑘1 ) est solution pour
−𝑘 𝑘 𝑘
𝑘 > 0.

16.2 Exercice 2 - Symétries du réseau

Pour un réseau à 1 couche, 𝑀 neurones intermédiaires et une fonction d’acti-

vation impaire, montrer que la fonction de perte quadratique ℒ(𝑊 ) présente
𝑀 axes de symétrie (on peut remplacer un poids par son inverse et compenser
ce changement de signe sur l’arête suivante) et que chaque vecteur de poids a
donc 2𝑀 vecteurs de poids qui lui sont équivalents. Montrer également qu’en
échangeant les arêtes entre elles, la fonction représentée par le réseau ne change
pas, ce qui implique également que chaque vecteur de poids a 𝑀 ! vecteurs de
poids qui lui sont équivalents de cette manière. En déduire que chaque vecteur
de poids a en fait 𝑀 !2𝑀 vecteurs équivalents.
16.3. EXERCICE 3 121

16.3 Exercice 3

On propose dans ce qui suit de créer et d’entraîner un réseau très simple à deux
couches et 𝑑 = 3 neurones. Ce réseau prend un scalaire 𝑥 en entrée et donne un
scalaire 𝑦 en sortie.

La première couche du réseau est représentée par une matrice de poids 𝑊 [1]
de taille 3 × 1 et un vecteur d’offset 𝑏[1] à 3 lignes. On utilise une fonction
d’activation tanh. A la sortie de la première couche on observe donc

𝐴[1] = tanh(𝑍 [1] ) avec 𝑍 [1] = 𝑊 [1] 𝑥 + 𝑏[1]

La matrice de poids 𝑊 [2] permettant de passer de la couche cachée à la sortie 𝑦

a donc 1 lignes et 3 colonnes, et le vecteur d’offset 𝑏[2] est un scalaire. La sortie
𝑦 ̂ est donc liée à 𝐴[1] par la relation

𝑦 ̂ = 𝑊 [2] 𝐴[1] + 𝑏[2] .

1. Dessiner ce réseau. Quelles sont la dimension de 𝐴[1] ?

x y

Le réseau faisant apparaître la fonction d’activation est le suivant

## Warning: Removed 6 rows containing missing values (geom_label).

122 CHAPITRE 16. TP5 - RÉSEAUX DE NEURONES - CORRIGÉ

z1 tanh

x z2 tanh y

z3 tanh

𝐴[1] a même dimension que 𝑍 [1] , à savoir 3 × 1.

̂ 𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) représentée par ce

2. Ecrire la fonction complète 𝑦(𝑥,
réseau.

[2] [1] [1] [2] [1] [1] [2] [1] [1]

𝑦 = 𝑊1 𝑡𝑎𝑛ℎ(𝑊1 𝑥+𝑏1 )+𝑊1 𝑡𝑎𝑛ℎ(𝑊2 𝑥+𝑏2 )+𝑊1 𝑡𝑎𝑛ℎ(𝑊3 𝑥+𝑏3 )+𝑏[2]

On souhaite utiliser ce réseau pour faire de la régression à partir de

𝑀 observations {(𝑥(𝑚) , 𝑦(𝑚) )}𝑚=1,…,𝑀 . On chercher donc les paramètres
(𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) qui minimisent la fonction de perte quadratique

𝑀
̂ (𝑚) , 𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) − 𝑦(𝑚) ‖2 .
ℒ(𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) = ∑ ‖𝑦(𝑥
𝑚=1

3. a. Quelle est la dérivée de ℒ par rapport à 𝑦 ̂ ?

Notons 𝑦[𝑚]
̂ ̂ (𝑚) , 𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] )
= 𝑦(𝑥

Les équations qui régissent le réseau et qu’il va falloir dériver sont alors
16.3. EXERCICE 3 123

ℒ = ∑(𝑦[𝑚] − 𝑦(𝑚) )2
𝑚
[1] [2]
𝑦[𝑚] = ∑ 𝐴𝑗𝑚 𝑤𝑗 + 𝑏[2]
𝑗
[1] [1]
𝐴𝑗𝑚 = 𝑡𝑎𝑛ℎ(𝑍𝑗𝑚 )
[1] [1] [1]
𝑍𝑗𝑚 = 𝑤𝑗 𝑥(𝑚) + 𝑏𝑗

En dérivant la première,

𝜕ℒ
= 2(𝑦[𝑚]
̂ − 𝑦(𝑚) )
𝜕 𝑦[𝑚]
̂

Le vecteur gradient des dérivées par rapport aux 𝑦[𝑚] est donc 𝑔𝑟𝑎𝑑𝑦 = 2(𝑦𝑝𝑟𝑒𝑑 −
𝑦)

b. Quelle est la dérivée de ℒ par rapport à 𝑊 [2] ?

𝜕ℒ 𝜕ℒ 𝜕 𝑦[𝑚]
̂ [1]
[2]
=∑ [2]
= ∑ 2(𝑦[𝑚]
̂ − 𝑦(𝑚) )𝐴𝑗𝑚
𝜕𝑊𝑗 𝑚
𝜕 𝑦[𝑚]
̂ 𝜕𝑊 𝑚
𝑗

Le vecteur ligne des trois dérivées partielles vérifie donc 𝑔𝑟𝑎𝑑𝑊 2 = (𝐴[1] 𝑔𝑟𝑎𝑑𝑦 )′ .

c. Quelle est la dérivée de ℒ par rapport à 𝑏[2] ?

𝜕ℒ 𝜕ℒ 𝜕 𝑦[𝑚]
̂
[2]
== ∑ [2]
= ∑ 2(𝑦[𝑚]
̂ − 𝑦(𝑚) )
𝜕𝑏 𝑚
𝜕 𝑦[𝑚]
̂ 𝜕𝑏 𝑚 𝑗

d. Quelle est la dérivée de ℒ par rapport à 𝐴[1] ?

𝜕ℒ [2]
= 2(𝑦[𝑚]
̂ − 𝑦(𝑚) )𝑊𝑖
𝜕𝐴𝑖𝑚

La matrice des dérivées partielles vérifie donc

𝑔𝑟𝑎𝑑𝐴 = (𝑊 [2] )′ 𝑔𝑟𝑎𝑑𝑦 .

e. Quelle est la dérivée de ℒ par rapport à 𝑍 [1] ?

124 CHAPITRE 16. TP5 - RÉSEAUX DE NEURONES - CORRIGÉ

𝐴 = 𝑡𝑎𝑛ℎ(𝑍) et 𝑡𝑎𝑛ℎ′ (𝑧) = 1 − 𝑡𝑎𝑛ℎ(𝑧)2 donc

𝜕ℒ 𝜕ℒ 𝜕𝐴𝑖𝑚 𝜕ℒ
= = (1 − 𝐴2𝑖𝑚 )
𝜕𝑍𝑖𝑚 𝜕𝐴𝑖𝑚 𝜕𝑍𝑖𝑚 𝜕𝐴𝑖𝑚

La matrice 𝑔𝑟𝑎𝑑𝑍 des dérivées partielles vérifie donc 𝑔𝑟𝑎𝑑𝑍 = 1 − (𝑔𝑟𝑎𝑑𝐴 )2 où

le 1 désigne la matrice de même taille où tous les coefficients sont égaux à 1.

f. Quelle est la dérivée de ℒ par rapport à 𝑊 [1] ?

[1]
𝜕ℒ 𝜕ℒ 𝜕𝑍𝑗𝑚 𝜕ℒ
[1]
=∑ [1] [1]
=∑ [1]
𝑥(𝑚)
𝜕𝑊𝑗 𝑚 𝜕𝑍𝑗𝑚 𝜕𝑊𝑗 𝑚 𝜕𝑍𝑗𝑚

Le vecteur des trois dérivées partielles vérifie donc 𝑔𝑟𝑎𝑑𝑊 1 = 𝑔𝑟𝑎𝑑𝑍 𝑥.

g. Quelle est la dérivée de ℒ par rapport à 𝑏[1] ?

[1]
𝜕ℒ 𝜕ℒ 𝜕𝑍𝑗𝑚 𝜕ℒ
[1]
=∑ [1] [1]
=∑ [1]
𝜕𝑏𝑗 𝑚 𝜕𝑍𝑗𝑚 𝜕𝑏𝑗 𝑚 𝜕𝑍𝑗𝑚

On reprend donc le produit matriciel précédent en remplaçant 𝑥 par le vecteur

ne contenant que des 1.

4. Pour créer la base des données d’entraînement, prendre par exemple,

pour les 𝑥(𝑚) , 30 points uniformément répartis sur l’intervalle [−1, 1] et
𝑦(𝑚) = 𝑓(𝑥(𝑚) ) avec 𝑓(𝑥) = 𝑥2 .

x=seq(from=-1,to=1,[Link]=30)
y=x^2
plot(x,y)
16.3. EXERCICE 3 125

1.0
0.8
0.6
y

0.4
0.2
0.0

−1.0 −0.5 0.0 0.5 1.0

5. Initialiser le réseau avec de poids aléatoires et faibles (par exemple dans

[−.1, .1])

w1 = matrix(runif(n=3,-1,1),3,1) #w1 vecteur colonne

b1 = matrix(runif(n=3,-1,1),3,1) #b1 vecteur colonne
w2 = matrix(runif(n=3,-1,1),1,3) #w2 vecteur ligne
b2 = runif(n=1,-1,1)

6. Entraîner le réseau en effectuant une descente de gradient, dans un pre-

mier temps avec un pas de 0.01.

Commençons par définir la fonction 𝑡𝑎𝑛ℎ, la prediction et l’erreur

tanh <- function(z){
return((exp(z)-exp(-z))/(exp(z)+exp(-z)))
}

prediction <- function(x,w1,b1,w2,b2){

Z <- w1 %*% matrix(x,1,length(x)) + b1%*% matrix(1,1,length(x))
return([Link](w2 %*% tanh(Z) +b2))
}

loss <- function(y_pred,y){

return(sum((y_pred-y)^2))
}
#gain=1 #gain en loss depuis le dernier pas
#epsilon = .00001 #niveau de gain auquel on arrête l'algorithme
rate=.01
126 CHAPITRE 16. TP5 - RÉSEAUX DE NEURONES - CORRIGÉ

for(i in 1:10000){

y_pred = prediction(x,w1,b1,w2,b2)

Z1 <- w1 %*% matrix(x,1,length(x)) + b1%*% matrix(1,1,length(x))

A1 <- tanh(Z1)

# calcul des gradients

grad_y_pred = 2*(y_pred-y)
grad_w2 = grad_y_pred %*% t(A1)
grad_b2 = sum(grad_y_pred)
grad_A1 = t(w2) %*% matrix(grad_y_pred,1,length(x))
grad_Z1 = grad_A1*(1-A1^2)
grad_w1 = grad_Z1 %*% x
grad_b1 = rowSums(grad_Z1)

#mise à jour des paramètres

w2 =w2 - rate*grad_w2
b2 =b2 - rate*grad_b2
w1 =w1 - rate*grad_w1
b1 =b1 - rate*grad_b1

y_pred = prediction(x,w1,b1,w2,b2)
y_pred

## [1] 0.988660366 0.868480450 0.750044543 0.636022296 0.528752606 0.430089860

## [7] 0.341330991 0.263222772 0.196032648 0.139658495 0.093752795 0.057842147
## [13] 0.031430262 0.014079086 0.005467248 0.005427285 0.013963598 0.031252356
## [19] 0.057623252 0.093521710 0.139449460 0.195881920 0.263163296 0.341385000
## [25] 0.430259784 0.529011448 0.636305389 0.750245096 0.868451060 0.988221596

7. Comparer la fonction apprise par notre réseau avec la fonction 𝑓 utilisée

pour créer les données.

plot_data <- [Link](x=x,

y=y,
y_pred=y_pred
)

ggplot(plot_data, aes(x)) +
geom_line(aes(y = y, colour = "y")) +
geom_line(aes(y = y_pred, colour = "y_pred"))
16.3. EXERCICE 3 127

1.00

0.75

colour
0.50 y
y

y_pred

0.25

0.00

−1.0 −0.5 0.0 0.5 1.0

x
La correspondance est parfaite

8. La fonction apprise par le réseau est-elle une bonne approximation de la

fonction 𝑓 en dehors de l’intervalle [−1, 1] ?

Regardons les prédictions sur un intervalle [−5, 5]

x=seq(-5,5,by=.1)

y_pred = prediction(x,w1,b1,w2,b2)

plot_data <- [Link](x=x,

y=x*x,
y_pred=y_pred
)

ggplot(plot_data, aes(x)) +
geom_line(aes(y = y, colour = "y")) +
geom_line(aes(y = y_pred, colour = "y_pred"))
128 CHAPITRE 16. TP5 - RÉSEAUX DE NEURONES - CORRIGÉ

25

20

15
colour
y
y

y_pred
10

−5.0 −2.5 0.0 2.5 5.0

x

En-dehors de l’intervalle où a été fait l’apprentissage, la prédiction

n’est pas du tout fiable.

8. Utiliser le même réseau pour les fonctions 𝑓(𝑥) = 𝑐𝑜𝑠(𝑥) sur le même
intervalle.

Commençons par entrainer le réseau

w1 = matrix(runif(n=3,-1,1),3,1) #w1 vecteur colonne
b1 = matrix(runif(n=3,-1,1),3,1) #b1 vecteur colonne
w2 = matrix(runif(n=3,-1,1),1,3) #w2 vecteur ligne
b2 = runif(n=1,-1,1)

x=seq(from=-3.14,3.14,by=0.1)
y=cos(x)

rate=.001

for(i in 1:10000){

y_pred = prediction(x,w1,b1,w2,b2)

Z1 <- w1 %*% matrix(x,1,length(x)) + b1%*% matrix(1,1,length(x))

A1 <- tanh(Z1)
16.3. EXERCICE 3 129

# calcul des gradients

grad_y_pred = 2*(y_pred-y)
grad_w2 = grad_y_pred %*% t(A1)
grad_b2 = sum(grad_y_pred)
grad_A1 = t(w2) %*% matrix(grad_y_pred,1,length(x))
grad_Z1 = grad_A1*(1-A1^2)
grad_w1 = grad_Z1 %*% x
grad_b1 = rowSums(grad_Z1)

#mise à jour des paramètres

w2 =w2 - rate*grad_w2
b2 =b2 - rate*grad_b2
w1 =w1 - rate*grad_w1
b1 =b1 - rate*grad_b1

On peut maintenant faire des prédictions sur par exemple l’intervalle [−5, 5]
tx <- seq(from=-5,to=5,by=.01)
ty <- prediction(tx,w1,b1,w2,b2)

plot_data <- [Link](x=tx,

y=cos(tx),
y_pred=ty
)

ggplot(plot_data, aes(x)) +
geom_line(aes(y = y, colour = "y")) +
geom_line(aes(y = y_pred, colour = "y_pred"))
130 CHAPITRE 16. TP5 - RÉSEAUX DE NEURONES - CORRIGÉ

1.0

0.5

colour
0.0
y
y

y_pred

−0.5

−1.0

−5.0 −2.5 0.0 2.5 5.0

x

Une fois de plus, on observe une très bonne prédiction sur l’intervalle sur lequel
on a appris mais elle ne se généralise pas au-delà.

9. Remplacer la fonction d’activation tanh par une autre fonction proposée

dans le cours. Quelles lignes du code doivent changer ?

L’ensemble du réseau et donc du code est identique sauf le passage de 𝑍 [1] à

𝐴[1] . Le formules de la propagation backward restent les mêmes sauf

[1]
𝜕ℒ 𝜕ℒ 𝜕𝐴𝑖 𝜕ℒ
[1]
= [1] [1]
= [1]
1𝑍 [1] >0
𝜕𝑍𝑖 𝜕𝐴𝑖 𝜕𝑍𝑖 𝜕𝐴𝑖 𝑖

Le gradient suivant 𝑍 [1] est donc simplement obtenu à partir du gradient suivant
𝐴[1] en annulant les coordonnées pour lesquelles 𝑍 [1] est négatif.
w1 = matrix(runif(n=3,-1,1),3,1) #w1 vecteur colonne
b1 = matrix(runif(n=3,-1,1),3,1) #b1 vecteur colonne
w2 = matrix(runif(n=3,-1,1),1,3) #w2 vecteur ligne
b2 = runif(n=1,-1,1)

x=seq(from=-3.14,3.14,by=0.1)
y=cos(x)

rate=.005
16.3. EXERCICE 3 131

relu <- function(x){ return(x*(x>0))}

prediction <- function(x,w1,b1,w2,b2){

Z <- w1 %*% matrix(x,1,length(x)) + b1%*% matrix(1,1,length(x))
return([Link](w2 %*% relu(Z) +b2))
}

loss <- function(y_pred,y){

return(sum((y_pred-y)^2))
}

for(i in 1:100000){

y_pred = prediction(x,w1,b1,w2,b2)
#print(i)
#print(y_pred)

Z1 <- w1 %*% matrix(x,1,length(x)) + b1%*% matrix(1,1,length(x))

A1 <- relu(Z1)

# calcul des gradients

grad_y_pred = 2*(y_pred-y)
grad_w2 = grad_y_pred %*% t(A1)
grad_b2 = sum(grad_y_pred)
grad_A1 = t(w2) %*% matrix(grad_y_pred,1,length(x))
grad_Z1 = grad_A1
grad_w1 = grad_Z1 %*% x
grad_b1 = rowSums(grad_Z1)

#mise à jour des paramètres

w2 =w2 - rate*grad_w2
b2 =b2 - rate*grad_b2
w1 =w1 - rate*grad_w1
b1 =b1 - rate*grad_b1

On peut maintenant faire des prédictions sur par exemple l’intervalle [−5, 5]
tx <- seq(from=-5,to=5,by=.01)
ty <- prediction(tx,w1,b1,w2,b2)

plot_data <- [Link](x=tx,

y=cos(tx),
y_pred=ty
132 CHAPITRE 16. TP5 - RÉSEAUX DE NEURONES - CORRIGÉ

ggplot(plot_data, aes(x)) +
geom_line(aes(y = y, colour = "y")) +
geom_line(aes(y = y_pred, colour = "y_pred"))

## Warning: Removed 1001 row(s) containing missing values (geom_path).

1.0

0.5

colour
0.0 y
y

y_pred

−0.5

−1.0

−5.0 −2.5 0.0 2.5 5.0

x

Le nombre de neurones choisis dans cette architecture n’est visiblement pas

suffisant pour aboutir à un résultat satisfaisant avec la fonction ReLu
Chapitre 17

TP6 - Réseaux de neurones

- Classification et Keras

library(keras)
library(ggplot2)

17.1 Exercice 1- Classification à 2 classes

Dans ce TP, on s’intéresse à un problème de classification supervisée dans R2 .

Etant donnée une base d’apprentissage de points du plan, classés en deux classes
𝒞0 et 𝒞1 , on souhaite apprendre une fonction permettant de prédire la classe de
n’importe quel point du plan (cette fonction segmente donc R2 en deux).

[Link].1 Données d’apprentissage. On crée dans ce qui suit un exemple

simple de données du plan R2 divisées en deux classes bien distinctes mais pas
linéairement séparables.
N = 100 # number of points per class
p = 2 # dimensionality of data
K = 2 # number of classes

X = matrix(0,N*K,p) # data matrix (each row = single example)

r = 0.5 # radius
t = runif(N,-pi/2,pi/2) # theta
X[1:N,1] = 0.3-2*r*cos(t)+ rnorm(N,0,0.02)
X[1:N,2] = r*sin(t) + rnorm(N,0,0.02)
t = runif(N,-pi/2,pi/2) # theta

133
134CHAPITRE 17. TP6 - RÉSEAUX DE NEURONES - CLASSIFICATION ET KERAS

X[N+1:N,1] = -.3+2*r*cos(t)+ rnorm(N,0,0.02)

X[N+1:N,2] = -0.5+r*sin(t) + rnorm(N,0,0.02)

y = [Link](c(rep(0,N),rep(1,N))) # class labels

dataclassif <- [Link](x1=X[,1],x2=X[,2],y=y)

On visualise ensuite les données

dataviz <- ggplot(dataclassif, aes(x=x1, y=x2,color=y)) + geom_point()
plot(dataviz)

0.5

0.0

y
x2

0
1

−0.5

−1.0

−0.4 0.0 0.4

x1

1. Expliquez comment les données sont créées.

Un réseau à deux couches pour la classification à entraîner

à la main

[Link].2 Structure du réseau. Pour apprendre notre fonction de clas-

sification, on propose d’entraîner un réseau de neurones à deux couches et 𝑑
neurones sur la couche intermédiaire. Ce réseau prend un point 𝑥 = (𝑥1 , 𝑥2 )
de R2 en entrée et donne un scalaire 𝑦 entre 0 et 1 en sortie, représentant la
probabilité que le point 𝑥 appartienne à la classe 𝒞0 .
La première couche du réseau est représentée par une matrice de poids 𝑊 [1]
de taille 𝑑 × 1 et un vecteur d’offset 𝑏[1] à 𝑑 lignes. On utilise une fonction
17.1. EXERCICE 1- CLASSIFICATION À 2 CLASSES 135

d’activation 𝑔 (par exemple 𝑡𝑎𝑛ℎ ou ReLU). A la sortie de la première couche

on observe donc
𝐴[1] = 𝑔(𝑍 [1] ) avec 𝑍 [1] = 𝑊 [1] 𝑥 + 𝑏[1]
La matrice de poids 𝑊 [2] permettant de passer de la couche cachée à la couche
de sortie a 1 lignes et 𝑑 colonnes, et le vecteur d’offset 𝑏[2] est un scalaire. On
applique sur la couche de sortie une fonction d’activation
1
𝜎(𝑧) =
1 + 𝑒−𝑧
pour obtenir une valeur entre 0 et 1. La sortie 𝑦 ̂ est donc liée à 𝐴[1] par la
relation
𝑦 ̂ = 𝜎(𝑍 [2] ) avec 𝑍 [2] = 𝜎(𝑊 [2] 𝐴[1] + 𝑏[2] ).
Pour simplifier les notations, on note dans ce qui suit 𝜃 = (𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] )
l’ensemble des paramètres du réseau.

2. Ecrire la fonction complète 𝑦(𝑥,

̂ 𝜃) représentée par ce réseau.

On souhaite utiliser ce réseau pour faire de la régression à partir de 𝑀 observa-

tions {(𝑥(𝑚) , 𝑦(𝑚) )}𝑚=1,…,𝑀 . Les 𝑥(𝑚) sont des points de R2 et les 𝑦(𝑚) valent 0
ou 1 selon que 𝑥(𝑚) appartienne à la classe 𝒞0 ou 𝒞1 . On cherche les paramètres
𝜃 = (𝑊 [1] , 𝑏[1] , 𝑊 [2] , 𝑏[2] ) qui minimisent la fonction de perte d’entropie croisée
ℒ(𝜃) = −𝑦(𝑚) log 𝑦(𝑥
̂ (𝑚) , 𝜃) − (1 − 𝑦(𝑚) ) log(1 − 𝑦(𝑥
̂ (𝑚) , 𝜃)).

Pour calculer le gradient de ℒ par rapport aux différents paramètres de 𝜃, on

raisonne par backpropagation (on pourra s’inspirer fortement des réponses du
TP précédent pour faire cette partie).

3. a. Ecrire les équations qui régissent le réseau.

b. Quelle est la dérivée de ℒ par rapport à 𝑦 ̂ ?
c. Quelle est la dérivée de ℒ par rapport à 𝑍 [2] ?
d. Quelle est la dérivée de ℒ par rapport à 𝑊 [2] ?
e. Quelle est la dérivée de ℒ par rapport à 𝑏[2] ?
f. Quelle est la dérivée de ℒ par rapport à 𝐴[1] ?
g. Quelle est la dérivée de ℒ par rapport à 𝑍 [1] ?
h. Quelle est la dérivée de ℒ par rapport à 𝑊 [1] ?
i. Quelle est la dérivée de ℒ par rapport à 𝑏[1] ?
4. Ecrire l’algorithme réalisant l’apprentissage du réseau.
5. Ecrire une fonction qui, en affectant chaque point de l’espace à usa classe
la plus probable, représente la segmentation du plan résultante.
6. a. Entraîner plusieurs fois le réseau, à partir d’initialisations différentes.
Qu’observez-vous ?

b. Ajouter une ligne dans le code permettant d’afficher la valeur de la fonc-

tion d’erreur toutes les 100 itérations. Commentez les résultats.
136CHAPITRE 17. TP6 - RÉSEAUX DE NEURONES - CLASSIFICATION ET KERAS

Le même réseau avec *keras*

Il existe plusieurs packages spécialisés pour éviter de coder les réseaux de neu-
rones à la main, la plupart sous Python : Tensorflow, Theano, Keras, Pytorch
(voir [Link] pour une liste de
librairies spécialisées en deep learning). On se propose d’utiliser keras, également
disponible sous R, pour recoder le réseau précédent.

On garde les données d’apprentissage déjà créées au début du TP et on les met

au bon format pour les utiliser avec keras (cf la vignette du package).
#mise en forme (cf vignette keras)
y=to_categorical(c(rep(0,N),rep(1,N)))
x=array_reshape(X,dim(X))

On définit ensuite le réseau avec les lignes suivantes.

model <- keras_model_sequential()
model %>%
layer_dense(units = 20, activation = 'relu', input_shape = c(2)) %>%
#layer_dropout(rate = 0.4) %>%
layer_dense(units = 20, activation = 'relu') %>%
#layer_dropout(rate = 0.3) %>%
#layer_dense(units = 1, activation = 'sigmoid')
layer_dense(units = 2, activation = 'softmax')

ainsi que la fonction de perte

model %>% compile(
#loss = 'binary_crossentropy',
loss = 'categorical_crossentropy',
optimizer = 'adam',
metrics = c('accuracy')
)

Le modèle peut maintenant être entraîné.

history <- model %>% fit(
x, y, epoch=60,
validation_split = 0.2,
verbose=FALSE
)
plot(history)

## `geom_smooth()` using formula 'y ~ x'

17.2. CLASSIFICATION À 3 CLASSES 137

0.8

0.6
loss

0.4

data
training
validation
0.75
accuracy

0.50

0.25

0.00

0 10 20 30 40 50 60
epoch

On peut à évaluer le score pour de nouveaux points. Ci-dessous, on le fait sur

une grille équirépartie sur le plan.
# etablissement de la grille
#x1grid <- seq(min(dataclassif$x1)-.5,max(dataclassif$x1)+.5,by=.02)
#x2grid <- seq(min(dataclassif$x2)-.5,max(dataclassif$x2)+.5,by=.02)
#xgrid <- [Link](x1grid,x2grid)

# prediction
#model %>% predict_classes(xgrid) -> ygrid

17.2 Classification à 3 classes

On s’intéresse maintenant à un cas à 3 classes. On créé les données d’apprentis-
sage (𝑥(𝑚) , 𝑦(𝑚) ) avec 𝑦(𝑚) ∈ {0, 1, 2} de la manière suivante :
N = 100 # number of points per class
D = 2 # dimensionality
K = 3 # number of classes

X = matrix(0,N*K,p) # data matrix (each row = single example)

y= rep(0,N*K)
for (j in 1:K){
ix = seq(N*(j-1)+1,N*j)
138CHAPITRE 17. TP6 - RÉSEAUX DE NEURONES - CLASSIFICATION ET KERAS

r = seq(0,1,by=1/(N-1)) # radius
t = seq(j*4,(j+1)*4,by=4/(N-1)) + runif(N)*0.2 # theta
X[ix,1] = r*sin(t)
X[ix,2] = r*cos(t)
y[ix] = j
}

dataclassif <- [Link](x1=X[,1],x2=X[,2],y=y)

On visualise ensuite les données

dataviz <- ggplot(dataclassif, aes(x=x1, y=x2,color=y)) + geom_point()
plot(dataviz)
1.0

0.5

y
3.0

2.5
x2

0.0
2.0

1.5

1.0
−0.5

−1.0
−0.5 0.0 0.5 1.0
x1

Créer l’aide de Pytorch un réseau de neurones à deux couches, 𝑑 neurones sur

la couche intermédiaire (prendre 𝑑 entre 10 et 30 par exemple) et 3 neurones
de sortie pour apprendre une fonction de classification à partir de ces données.
Comme fonction d’activation sur la couche intermédiaire, on pourra utiliser
𝑅𝑒𝐿𝑢. On définit la fonction de perte softmax de la manière suivante. Si 𝑦 ̂ =
(𝑦1̂ … , 𝑦3̂ ) est la sortie du réseau de neurones (ici, 𝑀 = 3) :
𝑀 𝑦̂
𝑒 𝑦(𝑚)
ℒ(𝑦,̂ 𝑦) = ∑ − log ( ).
𝑚=1
𝑒𝑦1̂ + ⋯ + 𝑒𝑦𝑀
̂
Bibliographie

Breiman, L. (2001). Random forests. Machine learning, 45(1) :5–32.

Breiman, L., Friedman, J., Stone, C. J., and Olshen, R. A. (1984). Classification
and regression trees. CRC press.
Nocedal, J. and Wright, S. (2006). Numerical optimization. Springer Science &
Business Media.
Van der Laan, M. J., Polley, E. C., and Hubbard, A. E. (2007). Super learner.
Statistical applications in genetics and molecular biology, 6(1).

139