Abonnez-vous à DeepL Pro pour éditer ce document.

Visitez www.DeepL.com/pro pour en savoir plus.

Optimisation du processus de
formation : sous-adaptation,
sur-adaptation, test,
4
et la régularisation

Dans ce chapitre
• qu'est-ce que l'underfitting et l'overfitting

• quelques solutions pour éviter l'overfitting : les tests, le

graphe de complexité du modèle et la régularisation

• calculer la complexité du modèle en utilisant les normes L1 et L2

• choisir le meilleur modèle en termes de performance et de complexité

Je suis allé déjeuner Oh Je ne suis jamais

et quand non ! pour
Je suis revenu, que vas-tu Encore un déjeuner.
mon modèle s'était faire ? Génial.
surajouté !
77
78 I
Chapitre 4 Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
régularisation

Ce chapitre est différent de la plupart des chapitres de ce livre, car il ne contient pas d'algorithme
d'apprentissage automatique particulier. Au lieu de cela, il décrit certains problèmes
potentiels auxquels les modèles d'apprentissage automatique peuvent être confrontés et des
moyens pratiques efficaces pour les résoudre.
Imaginez que vous avez appris d'excellents algorithmes d'apprentissage automatique et
que vous êtes prêt à les appliquer. Vous allez travailler en tant que scientifique des données,
et votre première tâche consiste à construire un modèle d'apprentissage automatique pour un
ensemble de données de clients. Vous le construisez et le mettez en production. Cependant, tout
se passe mal, et le modèle ne fait pas un bon travail de prédiction. Que s'est-il passé ?
Il s'avère que cette histoire est courante, car de nombreuses choses peuvent mal tourner
dans nos modèles. Heureusement, nous disposons de plusieurs techniques pour les améliorer.
Dans ce chapitre, je vous présente deux problèmes qui surviennent souvent lors de la
formation de modèles : l'underfitting et le overfitting. Je vous présente ensuite quelques
solutions pour éviter l'underfitting et le overfitting de nos modèles : le test et la validation, le
graphe de complexité du modèle et la régularisation.
Expliquons l'underfitting et le overfitting à l'aide de l'analogie suivante. Disons que nous devons
étudier pour un examen. Plusieurs choses peuvent mal tourner au cours de notre étude. Nous
n'avons peut-être pas assez étudié. Il n'y a aucun moyen d'y remédier et nous aurons
probablement de mauvais résultats à notre examen. Et si nous étudions beaucoup mais de la
mauvaise façon. Par exemple, au lieu de nous concentrer sur l'apprentissage, nous avons décidé de
mémoriser le manuel entier mot pour mot. Aurons-nous de bons résultats à notre test ? Il est
probable que non, car nous avons simplement tout mémorisé sans apprendre. La meilleure
option, bien sûr, serait d'étudier pour l'examen correctement et d'une manière qui nous permette
de répondre à de nouvelles questions que nous n'avons pas vues auparavant sur le sujet.
Dans le domaine de l'apprentissage automatique, l'adaptation insuffisante ressemble
beaucoup au fait de ne pas avoir suffisamment étudié pour un examen. Cela se produit
lorsque nous essayons d'entraîner un modèle trop simple, et qu'il est incapable d'apprendre
les données. La suradaptation ressemble beaucoup à la mémorisation de l'ensemble du
manuel scolaire au lieu d'étudier pour l'examen. Cela se produit lorsque nous essayons de
former un modèle trop complexe et qu'il mémorise les données au lieu de les apprendre
correctement. Un bon modèle, qui ne s'adapte ni trop ni pas assez, ressemble à un modèle qui
a bien étudié pour l'examen. Cela correspond à un bon modèle qui apprend les données
correctement et peut faire de bonnes prédictions sur de nouvelles données qu'il n'a pas vues.
Une autre façon de penser à l'underfitting et à l'overfitting, c'est lorsque nous avons une
tâche à accomplir. Nous pouvons commettre deux erreurs. Nous pouvons trop simplifier le
problème et proposer une solution trop simple. Nous pouvons également sursimplifier le problème
et proposer une solution trop complexe.
Imaginez que notre tâche consiste à tuer Godzilla, comme le montre la figure 4.1, et que
nous arrivions au combat équipés uniquement d'une tapette à mouches. C'est un exemple de
simplification excessive. L'approche ne sera pas bonne pour nous, car nous avons sous-estimé
le problème et n'étions pas préparés. Il s'agit d'une sous-adaptation: notre ensemble de données est
complexe, et nous venons le modéliser en n'étant équipés que d'un modèle simple. Le modèle ne
sera pas en mesure de capturer les complexités de l'ensemble de données.
En revanche, si notre tâche consiste à tuer une petite mouche et que nous utilisons un bazooka
 Un exemple d'ajustement insuffisant et excessif à l'aide de la 79
régression polynomiale.
pour y parvenir, il s'agit d'un exemple de complication excessive. Oui, nous tuerons peut-être la
mouche, mais nous détruirons également tout ce qui se trouve à portée de main et nous nous
mettrons en danger. Nous avons surestimé le problème, et notre solution n'était pas bonne. C'est
l'overfitting : nos données sont simples, mais nous essayons de les adapter à un modèle trop
complexe. Le modèle sera capable d'adapter nos données, mais il les mémorisera au lieu de les
apprendre. La première fois que j'ai appris l'overfitting, ma réaction a été : "Ce n'est pas un
problème. Si j'utilise un modèle trop complexe, je peux toujours modéliser mes données, non ?"
Exact, mais le vrai problème de l'overfitting est d'essayer de faire en sorte que le modèle fasse
des prédictions sur des données non vues. Comme nous le verrons plus loin dans ce chapitre, les
prédictions risquent d'avoir un aspect horrible.
80 I
Chapitre 4 Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
régularisation

Sous-adaptation Sur-adaptation

Figure 4.1 L'ajustement insuffisant et l'ajustement excessif sont deux problèmes qui peuvent survenir lors de la
formation de notre modèle d'apprentissage automatique. À gauche : l'ajustement insuffisant se produit lorsque
nous simplifions à l'extrême le problème à résoudre et que nous essayons de le résoudre à l'aide d'une solution
simple, par exemple en essayant de tuer Godzilla avec une tapette à mouches. A droite : L'adaptation excessive se
produit lorsque nous simplifions à l'extrême la solution d'un problème et que nous essayons de le résoudre à l'aide
d'une solution excessivement compliquée, comme essayer de tuer une mouche à l'aide d'un bazooka.

Comme nous l'avons vu dans la section "Paramètres et hyperparamètres" du chapitre 3,

chaque modèle d'apprentissage automatique possède des hyperparamètres, qui sont les
boutons que nous tournons et retournons avant de former le modèle. Il est extrêmement
important de définir les bons hyperparamètres pour notre modèle. Si nous en définissons mal
certains, nous risquons d'être sous-adaptés ou suradaptés. Les techniques que nous abordons
dans ce chapitre sont utiles pour nous aider à régler correctement les hyperparamètres.
Pour rendre ces concepts plus clairs, nous allons examiner un exemple avec un ensemble de
données et plusieurs modèles différents qui sont créés en modifiant un hyperparamètre particulier : le
degré d'un polynôme.
Vous pouvez trouver tout le code de ce chapitre dans le dépôt GitHub suivant : https://github.
.com/luisguiserrano/manning/tree/master/Chapitre_4_Testing_Overfitting_Underfitting.

Un exemple d'ajustement insuffisant et excessif à

l'aide de la régression polynomiale.
Dans cette section, nous verrons un exemple d'overfitting et de underfitting dans le même
ensemble de données. Observez attentivement l'ensemble de données de la figure 4.2 et
essayez d'ajuster un modèle de régression polynomial (voir la section "Que faire si les données
ne sont pas alignées ?" du chapitre 3). Réfléchissons au type de polynôme qui conviendrait à
cet ensemble de données. S'agirait-il d'une ligne, d'une parabole, d'une cubique ou peut-être
d'un polynôme de degré 100 ? Rappelez-vous que le degré d'un polynôme est l'exposant le
 Un exemple d'ajustement insuffisant et excessif à l'aide de la 81
régression
plus élevé présent. Par polynomiale.
exemple, le polynôme 2x14 + 9x6 - 3x + 2 est de degré 14.
82 I
Chapitre 4 Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
régularisation

Figure 4.2 Dans cet ensemble de données, nous formons certains modèles et présentons des problèmes de
formation tels que l'ajustement insuffisant et l'ajustement excessif. Si vous deviez adapter un modèle de
régression polynomiale à cet ensemble de données, quel type de polynôme utiliseriez-vous : une ligne, une
parabole ou autre ?

Je pense que cet ensemble de données ressemble beaucoup à une parabole qui s'ouvre vers le bas
(un visage triste). Il s'agit d'un polynôme de degré 2. Cependant, nous sommes des humains et
nous l'avons observé à l'œil. Un ordinateur ne peut pas faire cela. Un ordinateur doit essayer
plusieurs valeurs pour le degré du polynôme et choisir la meilleure. Disons que l'ordinateur va
essayer de l'ajuster avec des polynômes de degrés 1, 2 et 10. Lorsque nous ajustons des polynômes
de degré 1 (une ligne), 2 (un quadratique) et 10 (une courbe qui oscille au maximum neuf fois) à
cet ensemble de données, nous obtenons les résultats illustrés à la figure 4.3.

Modèle 1 Modèle Modèle 3

Polynôme de degré 1 2 Polynôme de degré 10
(une ligne) Polynôme de degré 2
(une parabole)

Figure 4.3 Ajustement de trois modèles au même ensemble de données. Le modèle 1 est un polynôme de degré
1, qui est une ligne. Le modèle 2 est un polynôme de degré 2, ou un quadratique. Le modèle 3 est un
polynôme de degré 10. Un
Lequel semble
exemple le mieux insuffisant
d'ajustement correspondre ?
et excessif à l'aide de la 83
régression polynomiale.
 Comment faire pour que l'ordinateur choisisse le bon modèle ? En 81
testant

Dans la figure 4.3, nous voyons trois modèles, le modèle 1, le modèle 2 et le modèle 3.
Remarquez que le modèle 1 est trop simple, car il s'agit d'une ligne qui tente de s'adapter à un
ensemble de données quadratiques. Il n'y a aucune chance de trouver une bonne ligne pour
ajuster cet ensemble de données, car l'ensemble de données ne ressemble tout simplement
pas à une ligne. Par conséquent, le modèle 1 est un exemple clair de sous-adaptation. Le
modèle 2, en revanche, s'adapte plutôt bien aux données. Ce modèle n'est ni surajusté ni
sous-ajusté. Le modèle 3 s'ajuste extrêmement bien aux données, mais il passe complètement
à côté de l'essentiel. Les données sont censées ressembler à une parabole avec un peu de
bruit, et le modèle dessine un polynôme très compliqué de degré 10 qui parvient à passer par
chacun des points mais ne capture pas l'essence des données. Le modèle 3 est un exemple
clair de sur-ajustement.
Pour résumer le raisonnement précédent, voici une observation que nous utilisons tout au
long de ce chapitre, et dans de nombreux autres épisodes de ce livre : les modèles très simples
ont tendance à être sous-adaptés. Les modèles très complexes ont tendance à être surajustés.
L'objectif est de trouver un modèle qui ne soit ni trop simple ni trop complexe et qui capture
bien l'essence de nos données.
Nous sommes sur le point d'arriver à la partie la plus difficile. En tant qu'humains, nous
savons que le meilleur ajustement est donné par le modèle 2. Mais que voit l'ordinateur ?
L'ordinateur ne peut que calculer les fonctions d'erreur. Comme vous vous en souvenez peut-
être, au chapitre 3, nous avons défini deux fonctions d'erreur : l'erreur absolue et l'erreur au
carré. Pour des raisons de clarté visuelle, nous utiliserons dans cet exemple l'erreur absolue, qui
est la moyenne des sommes des valeurs absolues des distances entre les points et la courbe,
bien que les mêmes arguments soient valables pour l'erreur carrée. Pour le modèle 1, les points
sont éloignés du modèle, cette erreur est donc importante. Pour le modèle 2, ces distances sont
faibles, donc l'erreur est faible. Cependant, pour le modèle 3, les distances sont nulles car les
points tombent tous dans la courbe réelle ! Cela signifie que l'ordinateur va penser que le
modèle parfait est le modèle 3. Ce n'est pas bon. Nous devons trouver un moyen de dire à
l'ordinateur que le meilleur modèle est le modèle 2 et que le modèle 3 est surajusté. Comment
pouvons-nous faire cela ? Je vous encourage à poser ce livre pendant quelques minutes et à
réfléchir vous-même à quelques idées, car il existe plusieurs solutions à ce problème.

Comment faire pour que l'ordinateur choisisse le

bon modèle ? En testant
Une façon de déterminer si un modèle est surajusté est de le tester, et c'est ce que nous
faisons dans cette section. Tester un modèle consiste à choisir un petit ensemble de points
dans l'ensemble de données et à choisir de les utiliser non pas pour former le modèle mais
pour tester les performances du modèle. Cet ensemble de points est appelé l'ensemble de
test. L'ensemble de points restant (la majorité), que nous utilisons pour former le modèle, est
appelé ensemble de formation. Une fois le modèle formé sur l'ensemble de formation, nous
utilisons l'ensemble de test pour évaluer le modèle. De cette façon, nous nous assurons que le
modèle est capable de généraliser à des données non vues, plutôt que de mémoriser l'ensemble
82 Chapitre 4 I Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
d'apprentissage.
régularisation Pour revenir à l'analogie de l'examen, imaginons la formation et le test de cette
manière. Disons que le livre que nous étudions pour l'examen comporte 100 questions à la fin.
Nous en choisissons 80 pour nous entraîner, ce qui signifie que nous les étudions attentivement,
que nous cherchons les réponses et que nous les apprenons. Puis nous utilisons les 20
questions restantes pour nous tester - nous essayons d'y répondre sans regarder le livre,
comme dans le cadre d'un examen.
Voyons maintenant comment cette méthode se présente avec notre ensemble de données
et nos modèles. Remarquez que le véritable problème du modèle 3 n'est pas qu'il ne s'adapte
pas aux données, mais qu'il ne se généralise pas bien aux nouvelles données.
 Comment faire pour que l'ordinateur choisisse le bon modèle ? En 83
testant

données. En d'autres termes, si vous entraîniez le modèle 3 sur cet ensemble de données et
que de nouveaux points apparaissaient, feriez-vous confiance au modèle pour faire de bonnes
prédictions avec ces nouveaux points ? Probablement pas, car le modèle a simplement
mémorisé l'ensemble des données sans en saisir l'essence. Dans ce cas, l'essence de
l'ensemble de données est qu'il ressemble à une parabole qui s'ouvre vers le bas.
Dans la figure 4.4, nous avons dessiné deux triangles blancs dans notre ensemble de
données, représentant l'ensemble de test. L'ensemble d'apprentissage correspond aux cercles
noirs. Examinons maintenant cette figure en détail et voyons comment ces trois modèles se
comportent avec nos ensembles de formation et de test. En d'autres termes, examinons l'erreur
que le modèle produit dans les deux ensembles de données. Nous appellerons ces deux erreurs
l'erreur de formation et l'erreur de test.
La ligne supérieure de la figure 4.4 correspond à l'ensemble d'entraînement et la ligne inférieure
à l'ensemble de test. Pour illustrer l'erreur, nous avons tracé des lignes verticales entre le point et
le modèle. L'erreur abso- lue moyenne est précisément la moyenne des longueurs de ces lignes. En
regardant la ligne supérieure, nous pouvons voir que le modèle 1 a une erreur d'apprentissage
importante, le modèle 2 a une petite erreur d'apprentissage et le modèle 3 a une erreur
d'apprentissage minuscule (zéro, en fait). Ainsi, le modèle 3 fait le meilleur travail sur
l'ensemble de formation.

Modèle 1 Modèle 2 Modèle 3

(degré 1) (degré 2) (degré 10)

Erreur
de
format
ion
Haut Faible Très faible

Erreur
de
test

Haut Faible Haut

Figure 4.4 Nous pouvons utiliser ce tableau pour décider du degré de complexité de notre modèle. Les colonnes
représentent les trois modèles de degré 1, 2 et 10. Les colonnes représentent l'erreur d'apprentissage et l'erreur de
test. Les cercles pleins représentent l'ensemble d'apprentissage, et les triangles blancs l'ensemble de test. Les
erreurs à chaque point peuvent être vues comme les lignes verticales du point à la courbe. L'erreur de chaque
modèle est l'erreur absolue moyenne donnée par la moyenne de ces longueurs verticales. Remarquez que l'erreur
d'apprentissage diminue à mesure que la complexité du modèle augmente. Cependant, l'erreur de test diminue
puis augmente à nouveau avec la complexité du modèle. D'après ce tableau, nous concluons que parmi ces trois
modèles, le meilleur est le modèle 2, car il nous donne une erreur de test faible.
84 I
Chapitre 4 Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
régularisation
Cependant, lorsque nous arrivons à l'ensemble de test, les choses changent. Le modèle 1
présente toujours une erreur de test importante, ce qui signifie qu'il s'agit tout simplement
d'un mauvais modèle, dont les performances sont inférieures à celles de l'ensemble de
formation et de l'ensemble de test : il est sous-adapté. Le modèle 2 a une petite erreur de test, ce
qui signifie qu'il s'agit d'un bon modèle, car il s'adapte aux deux ensembles de test.
 Comment faire pour que l'ordinateur choisisse le bon modèle ? En 85
testant

l'ensemble de formation et l'ensemble de test. Le modèle 3, cependant, produit une erreur de test
importante. Parce qu'il a fait un si mauvais travail d'ajustement de l'ensemble de test, mais un
si bon travail d'ajustement de l'ensemble d'apprentissage, nous con-cluons que le modèle 3
s'adapte trop.
Résumons ce que nous avons appris jusqu'à présent.
Les modèles peuvent
• Underfit : utiliser un modèle trop simple pour notre jeu de données.
• Bien adapter les données : utiliser un modèle dont la complexité est adaptée à notre
ensemble de données.
• Overfit : utiliser un modèle trop complexe pour notre
jeu de données. Dans l'ensemble d'entraînement
• Le modèle sous-adapté aura de mauvais résultats (erreur d'apprentissage importante).
• Le bon modèle donnera de bons résultats (petite erreur d'apprentissage).
• Le modèle surajusté donnera de très bons résultats (erreur
d'apprentissage très faible). Dans l'ensemble de test
• Le modèle sous-adapté aura de mauvais résultats (erreur de test importante).
• Le bon modèle donnera de bons résultats (petite erreur de test).
• Le modèle surajusté aura de mauvais résultats (erreur de test importante).
Ainsi, pour savoir si un modèle est sous-adapté, sur-adapté ou bon, il faut examiner les erreurs
d'apprentissage et de test. Si les deux erreurs sont élevées, le modèle est sous-adapté. Si les
deux erreurs sont faibles, il s'agit d'un bon modèle. Si l'erreur d'apprentissage est faible et que
l'erreur de test est élevée, le modèle est surdimensionné.

Comment choisir l'ensemble de tests, et quelle doit être sa taille ?

J'ai une question. D'où ai-je tiré ces deux nouveaux points ? Si nous formons un modèle en
production où les données circulent en permanence, nous pouvons choisir certains des nouveaux
points comme données de test. Mais que se passe-t-il si nous n'avons pas la possibilité d'obtenir de
nouveaux points et que tout ce que nous avons est notre ensemble de données original de 10
points ? Dans ce cas, nous sacrifions une partie de nos données et l'utilisons comme ensemble
de test. Combien de données ? Cela dépend de la quantité de données dont nous disposons et de
l'efficacité que nous souhaitons obtenir du modèle, mais en pratique, toute valeur comprise
entre 10 et 20 % semble bien fonctionner.

Pouvons-nous utiliser nos données de test pour l'entraînement du modèle ? Non.

Dans le domaine de l'apprentissage automatique, nous devons toujours respecter une règle
importante : lorsque nous divisons nos données en deux catégories, à savoir les données
d'apprentissage et les données de test, nous devons utiliser les données d'apprentissage pour
former le modèle et ne toucher en aucun cas aux données de test lors de la formation du
86 Chapitre 4 I Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
modèle ou de la prise de décision concernant les hyperparamètres du modèle. Le non-respect
régularisation
de cette consigne risque d'entraîner un surajustement, même s'il n'est pas perceptible par un
humain. Dans de nombreux concours d'apprentissage automatique, des équipes ont soumis
des modèles qu'elles pensaient être merveilleux, mais qui ont échoué lamentablement
lorsqu'ils ont été testés sur un ensemble de données secret. Cela peut être dû au fait que les
scientifiques chargés de la formation des modèles ont, d'une manière ou d'une autre, (peut-
être par inadvertance)
 Comment faire pour que l'ordinateur choisisse le bon modèle ? En 87
testant

utiliser les données de test pour les former. En fait, cette règle est si importante que nous en
ferons la règle d'or de ce livre.

Règle d'or : tu n'utiliseras jamais tes données de test pour la formation.

Pour l'instant, il semble que ce soit une règle facile à suivre, mais comme nous allons le voir, c'est
une règle très facile à enfreindre.
En fait, nous avons déjà enfreint la règle d'or au cours de ce chapitre. Pouvez-vous dire où ?
Je vous encourage à revenir en arrière et à trouver où nous l'avons cassé. Nous verrons où dans la
prochaine section.

Où avons-nous enfreint la règle d'or, et

comment y remédier ? Le jeu de validation
Dans cette section, nous verrons où nous avons enfreint la règle d'or et nous apprendrons une
technique appelée validation, qui viendra à notre secours.
Nous avons enfreint la règle d'or dans la section "Comment faire pour que l'ordinateur
choisisse le bon modèle". Rappelez-vous que nous avions trois modèles de régression polynomiale
: un de degré 1, un de degré 2 et un de degré 10, et que nous ne savions pas lequel choisir.
Nous avons utilisé nos données d'entraînement pour entraîner les trois modèles, puis nous
avons utilisé les données de test pour décider du modèle à choisir. Nous ne sommes pas
censés utiliser les données de test pour entraîner notre modèle ou pour prendre une
quelconque décision concernant le modèle ou ses hyperparamètres. Si nous le faisons, nous
risquons de faire de l'overfitting ! Nous sommes potentiellement surajustés chaque fois que
nous construisons un modèle qui s'adapte trop à notre ensemble de données.
Que pouvons-nous faire ? La solution est simple : nous cassons encore plus notre ensemble de
données. Nous introduisons un nouvel ensemble, l'ensemble de validation, que nous utilisons
ensuite pour prendre des décisions sur notre ensemble de données. En résumé, nous divisons
notre ensemble de données en trois ensembles :
• Ensemble d'entraînement : pour l'entraînement de tous nos modèles
• Ensemble de validation : pour prendre des décisions sur le choix du modèle à utiliser
• Jeu d'essai : pour vérifier l'efficacité de notre modèle.
Ainsi, dans notre exemple, nous aurions deux points supplémentaires à utiliser pour la
validation, et l'examen de l'erreur de validation devrait nous aider à décider que le meilleur
modèle à utiliser est le modèle 2. Nous devrions utiliser l'ensemble de test à la toute fin, pour
voir comment notre modèle s'est comporté. Si le modèle n'est pas bon, nous devons tout jeter
et repartir de zéro.
En termes de taille des ensembles de test et de validation, il est courant d'utiliser une
répartition 60-20-20 ou 80-10-10, c'est-à-dire 60 % de formation, 20 % de validation, 20 % de
test, ou 80 % de formation, 10 % de validation, 10 % de test. Ces chiffres sont arbitraires, mais
ils ont tendance à bien fonctionner, car ils laissent la plupart des données pour la formation
88 I
Chapitre 4 Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
régularisation
tout en nous permettant de tester le modèle dans un ensemble suffisamment grand.
 Un moyen numérique de décider de la complexité de notre modèle : Le graphique de complexité du
modèle85

Un moyen numérique de décider de la complexité

de notre modèle : Le graphique de complexité du
modèle
Dans les sections précédentes, nous avons appris à utiliser l'ensemble de validation pour nous aider
à décider quel modèle était le meilleur parmi trois modèles différents. Dans cette section, nous
allons découvrir un graphe appelé graphe de complexité du modèle, qui nous aide à choisir
parmi beaucoup plus de modèles. Imaginez que nous disposions d'un ensemble de données
différent et beaucoup plus complexe, et que nous essayions de construire un modèle de régression
polynomiale pour l'ajuster. Nous voulons décider du degré de notre modèle parmi les nombres
compris entre 0 et 10 (inclusif). Comme nous l'avons vu dans la section précédente, la façon de
décider du modèle à utiliser est de choisir celui qui a la plus petite erreur de validation.
Cependant, le tracé des erreurs d'apprentissage et de test peut nous fournir des
informations précieuses et nous aider à examiner les tendances. Dans la figure 4.5, vous
pouvez voir un graphique dans lequel l'axe horizontal représente le degré du polynôme du
modèle et l'axe vertical représente la valeur de l'erreur. Les diamants représentent l'erreur de
formation, et les cercles l'erreur de validation. Il s'agit du graphique de la complexité du
modèle.

Erreur de
formation
Erreur de
validation

Meilleur
modèle
Erreur (erreur absolue
moyenne)

1 2 3 4 5 6 7 8 9 10
Complexité du modèle (degré du polynôme)

Figure 4.5 Le graphique de complexité du modèle est un outil efficace pour nous aider à déterminer la complexité
idéale d'un modèle afin d'éviter l'underfitting et le overfitting. Dans ce graphique de complexité de modèle, l'axe
horizontal représente le degré de plusieurs modèles de régression polynomiale, de 0 à 10 (c'est-à-dire la complexité
du modèle). L'axe vertical représente l'erreur, qui dans ce cas est donnée par l'erreur absolue moyenne.
Remarquez que l'erreur de formation commence par être importante et qu'elle diminue à mesure que nous nous
90 déplaçons vers 4
Chapitre I
la droite. Cela s'explique
Optimisation par le
du processus
d'améliorer la qualité de l'apprentissage.
defait que plus
formation notre modèle estsur-adaptation,
: Sous-adaptation, complexe, plus il est
test et capable
régularisation
s'adaptent aux données d'apprentissage. L'erreur de validation, cependant, commence par être importante, puis
diminue, et augmente à nouveau - les modèles très simples ne peuvent pas bien s'adapter à nos données (ils sont
sous-adaptés), tandis que les modèles très complexes s'adaptent à nos données d'apprentissage, mais pas à nos
données de validation, car ils sont suradaptés. Un point heureux au milieu est celui où notre modèle ne s'adapte ni
trop ni pas assez, et nous pouvons le trouver en utilisant le graphique de complexité du modèle.
86 I
Chapitre 4 Optimisation du processus de formation : Sous-assignation, sur-assignation, test et
régularisation

Remarquez que dans le graphique de complexité du modèle de la figure 4.5, la valeur la plus
faible pour l'erreur de validation se produit au degré 4, ce qui signifie que pour cet ensemble de
données, le modèle le mieux ajusté (parmi ceux que nous considérons) est un modèle de
régression polynomiale de degré 4. En regardant à gauche du graphique, nous pouvons voir que
lorsque le degré du polynôme est petit, les erreurs de formation et de validation sont grandes, ce
qui implique que les modèles sont sous-adaptés. En regardant à droite du graphique, nous pouvons
voir que l'erreur d'apprentissage devient de plus en plus petite, mais que l'erreur de validation
devient de plus en plus grande, ce qui implique que les modèles sont surajustés. Le point idéal se
situe autour de 4, qui est le modèle que nous choisissons.
L'un des avantages du graphique de complexité du modèle est que, quelle que soit la taille
de notre ensemble de données ou le nombre de modèles différents que nous essayons, il
ressemble toujours à deux courbes : une qui diminue toujours (l'erreur d'apprentissage) et
une qui diminue puis remonte (l'erreur de validation). Bien sûr, dans un ensemble de données
vaste et complexe, ces courbes peuvent osciller, et le comportement peut être plus difficile à
repérer. Cependant, le graphique de complexité du modèle est toujours un outil utile pour les
scientifiques des données, qui peuvent ainsi trouver un bon point dans ce graphique et décider
de la complexité de leurs modèles afin d'éviter à la fois le sous-ajustement et le surajustement.
Pourquoi avons-nous besoin d'un tel graphique si tout ce que nous devons faire est de
choisir le modèle avec l'erreur de validation la plus faible ? Cette méthode est vraie en
théorie, mais en pratique, en tant que scientifique des données, vous avez peut-être une bien
meilleure idée du problème que vous résolvez, des contraintes et des critères de référence. Si
vous constatez, par exemple, que le modèle présentant la plus petite erreur de validation est
tout de même assez complexe et qu'il existe un modèle beaucoup plus simple dont l'erreur de
validation n'est que légèrement supérieure, vous serez peut-être plus enclin à choisir ce modèle.
Un grand scientifique des données est celui qui peut combiner ces outils théoriques avec sa
connaissance du cas d'utilisation pour construire les modèles les meilleurs et les plus efficaces.

Une autre alternative pour éviter

l'overfitting : Régularisation
Dans cette section, nous abordons une autre technique utile pour éviter l'overfitting dans nos
modèles qui ne nécessite pas de jeu de test : la régularisation. La régularisation repose sur la
même observation que celle faite dans la section "Exemple de sous-adaptation et de sur-
adaptation à l'aide de la régression polynomiale", où nous avons conclu que les modèles
simples ont tendance à être sous-adaptés et les modèles complexes à être sur-adaptés.
Cependant, dans les méthodes précédentes, nous avons testé plusieurs modèles et sélectionné
celui qui conciliait le mieux performance et complexité. En revanche, lorsque nous utilisons la
régularisation, nous n'avons pas besoin d'entraîner plusieurs modèles. Nous formons simplement
le modèle une fois, mais pendant la formation, nous essayons non seulement d'améliorer les
performances du modèle, mais aussi de réduire sa complexité. La clé pour y parvenir est de
mesurer à la fois les performances et la complexité.
Avant d'entrer dans les détails, discutons d'une analogie pour réfléchir à la mesure de la
 Une autre alternative pour éviter l'overfitting : 87
Régularisation
performance et de la complexité des modèles. Imaginons que nous ayons trois maisons, et qu'elles
aient toutes le même problème : le toit fuit (figure 4.6). Trois couvreurs viennent, et chacun
répare une des maisons. Le premier couvreur a utilisé un pansement, le deuxième des bardeaux et
le troisième du titane. D'après notre intuition, il semble que le meilleur soit le couvreur 2, car
le couvreur 1 a trop simplifié le problème (sous-adaptation) et le couvreur 3 l'a trop compliqué
(sur-adaptation).
88 I
Chapitre 4 Optimisation du processus de formation : Sous-assignation, sur-assignation, test et
régularisation

Problème : toit brisé

Solution du Solution du Solution du

couvreur 1 : couvreur 2 : couvreur 3 :
Bandage (sous- Bardeaux Titane
adaptation) (Correct) (surcharge)

Figure 4.6 Une analogie pour l'underfitting et le overfitting. Notre problème consiste en un toit cassé. Nous avons
trois couvreurs qui peuvent le réparer. Le couvreur 1 vient avec un bandage, le couvreur 2 vient avec des
bardeaux et le couvreur 3 vient avec un bloc de titane. Le couvreur 1 a trop simplifié le problème, il représente
donc un sous-équipement. Le couvreur 2 a utilisé une bonne solution. Le couvreur 3 a trop compliqué la solution, il
représente donc un surajustement.

Cependant, nous devons prendre nos décisions à l'aide de chiffres, alors prenons quelques
mesures. La façon de mesurer la performance des couvreurs est de savoir combien d'eau a
coulé après qu'ils aient réparé leur toit. Ils ont obtenu les résultats suivants :
Performance (en ml d'eau fuie)
Couvreur 1 : 1000 ml d'eau
Couvreur 2 : 1 ml d'eau
Couvreur 3 : 0 mL d'eau
Il semble que le couvreur 1 ait eu une performance terrible, car le toit continue de laisser
échapper de l'eau. Cependant, entre les couvreurs 2 et 3, lequel choisissons-nous ? Peut-être
le couvreur 3, qui a eu une meilleure performance ? La mesure de la performance n'est pas
assez bonne ; elle élimine correctement le couvreur 1 de l'équation, mais elle nous dit à tort
de choisir le couvreur 3, au lieu du couvreur 2. Nous avons besoin d'une mesure de leur
complexité pour nous aider à prendre la bonne décision. Une bonne mesure de leur
complexité est le montant qu'ils nous ont facturé pour réparer le toit, en dollars. Les prix
étaient les suivants :
Complexité (en prix)
Couvreur 1 : $1
Couvreur 2 : 100
Couvreur 3 : 100 000 Une autre alternative pour éviter l'overfitting : 89
Régularisation
90 I
Chapitre 4 Optimisation du processus de formation : Sous-assignation, sur-assignation, test et
régularisation

Nous pouvons maintenant dire que le couvreur 2 est meilleur que le couvreur 3, car ils ont eu la
même performance, mais le couvreur 2 a facturé moins cher. Cependant, le couvreur 1 était le
moins cher - pourquoi ne pas l'avoir choisi ? Il semble que ce dont nous avons besoin, c'est de
combiner les mesures de performance et de complexité. Nous pouvons additionner la quantité
d'eau que le toit a laissé s'échapper et le prix, pour obtenir ce qui suit :
Performance + complexité
Couvreur 1 : 1001
Couvreur 2 : 101
Couvreur 3 : 100 000
Il est maintenant clair que le couvreur 2 est le meilleur, ce qui signifie que l'optimisation des
performances et de la complexité en même temps donne de bons résultats qui sont également
aussi simples que possible. C'est le but de la régu- lisation : mesurer la performance et la
complexité avec deux fonctions d'erreur différentes, et les additionner pour obtenir une
fonction d'erreur plus robuste. Cette nouvelle fonction d'erreur garantit que notre modèle est
performant et peu complexe. Dans les sections suivantes, nous verrons plus en détail
comment définir ces deux fonctions d'erreur. Mais avant cela, examinons un autre exemple
d'overfitting.
Un autre exemple d'ajustement excessif : Les recommandations de films
Dans cette section, nous découvrons une manière plus subtile dont un modèle peut être
surajusté - cette fois-ci, elle n'est pas liée au degré du polynôme mais au nombre de
caractéristiques et à la taille des coefficients. Imaginons que nous ayons un site web de
streaming de films et que nous essayions de construire un système de recommandation. Pour
simplifier, imaginons que nous n'ayons que 10 films : M1, M2, ..., M10. Un nouveau film, M11,
sort, et nous aimerions construire un modèle de régression linéaire pour recommander le film 11
en fonction des 10 précédents. Nous disposons d'un ensemble de données de 100 utilisateurs.
Pour chaque utilisateur, nous avons 10 caractéristiques, qui sont les temps (en secondes)
pendant lesquels l'utilisateur a regardé chacun des 10 films originaux. Si l'utilisateur n'a pas
regardé de film, cette quantité est égale à 0. L'étiquette de chaque utilisateur est le temps
pendant lequel il a regardé le film 11. Nous voulons construire un modèle qui s'adapte à cet
ensemble de données. Étant donné que le modèle est un modèle de régression linéaire, l'équation
pour le temps prédit où l'utilisateur regardera le film 11 est linéaire, et elle ressemblera à ce qui
suit :
yˆ = w1x1 + w2x2 + w3x3+ w4x4 + w5x5 + w6x6 + w7x7 + w8x8 ++ w9x9 + w10x10 + b,
où
• yˆ est la durée pendant laquelle le modèle prédit que l'utilisateur va regarder le film 11,
• xi est le temps pendant lequel l'utilisateur a regardé le film i, pour i = 1, 2, ..., 10,
• wi est le poids associé au film i, et
• b est le biais.
 Une autre alternative pour éviter l'overfitting : 91
Régularisation
Testons maintenant notre intuition. Parmi les deux modèles suivants (donnés par leur équation),
lequel (ou lesquels) semble(nt) être surajusté(s) ?
92 I
Chapitre 4 Optimisation du processus de formation : Sous-assignation, sur-assignation, test et
régularisation
Modèle 1 : yˆ = 2x3 + 1,4x7 - 0,5x7 + 4
Modèle 2 : yˆ = 22x1 - 103x2 - 14x3 + 109x4 - 93x5 + 203x6 + 87x7 - 55x8 + 378x9 - 25x10 + 8
Si vous pensez comme moi, le modèle 2 semble un peu compliqué, et c'est peut-être celui qui
s'adapte trop. L'intuition ici est qu'il est peu probable que le temps pendant lequel un utilisateur a
regardé le film 2 doive être multiplié par -103 et ensuite ajouté à d'autres nombres pour obtenir la
prédiction. Cette méthode peut s'adapter aux données, mais elle donne l'impression de
mémoriser les données au lieu de les apprendre.
Le modèle 1, en revanche, semble beaucoup plus simple, et il nous donne des informations
intéressantes. Le fait que la plupart des coefficients soient nuls, à l'exception de ceux des films 3, 7
et 9, nous indique que les trois seuls films liés au film 11 sont ces trois films. En outre, comme les
coefficients des films 3 et 7 sont positifs, le modèle nous dit que si un utilisateur a regardé le
film 3 ou le film 7, il est probable qu'il regarde le film 11. Comme le coefficient du film 9 est négatif,
si l'utilisateur a regardé le film 9, il est peu probable qu'il regarde le film 11.
Notre objectif est d'avoir un modèle comme le modèle 1 et d'éviter les modèles comme le
modèle 2. Mais malheureusement, si le modèle 2 produit une erreur plus faible que le modèle
2, alors l'exécution de l'algorithme de régression linéaire sélectionnera le modèle 2 à la place.
Que pouvons-nous faire ? C'est ici que la régularisation vient à la rescousse. La première chose
dont nous avons besoin est une mesure qui nous indique que le modèle 2 est beaucoup plus
complexe que le modèle 1.
Mesurer la complexité d'un modèle : Normes L1 et L2
Dans cette section, nous apprenons deux façons de mesurer la complexité d'un modèle. Mais avant
cela, examinons les modèles 1 et 2 de la section précédente et essayons de trouver une formule qui
soit faible pour le modèle 1 et élevée pour le modèle 2.
Notez qu'un modèle comportant plus de coefficients, ou des coefficients de valeur plus élevée, a
tendance à être plus complexe. Par conséquent, toute formule qui correspond à cela fonctionnera,
comme la suivante :
• La somme des valeurs absolues des coefficients
• La somme des carrés des coefficients
La première est appelée la norme L1, et la seconde la norme L2. Elles proviennent d'une
théorie plus générale des espaces LP , nommée d'après le mathématicien français Henri
Lebesgue. Nous utilisons les valeurs absolues et les carrés pour nous débarrasser des coefficients
négatifs ; sinon, les grands nombres négatifs s'annuleront avec les grands nombres positifs, et
nous pourrions nous retrouver avec une petite valeur pour un modèle très complexe.
Mais avant de commencer à calculer les normes, un petit détail technique : le biais dans les
modèles n'est pas inclus dans la norme L1 et L2. Pourquoi ? Eh bien, le biais du modèle est
précisément le nombre de secondes pendant lesquelles nous nous attendons à ce qu'un
utilisateur regarde le film 11 s'il n'a regardé aucun des 10 films précédents. Ce nombre n'est pas
associé à la complexité du modèle ; par conséquent, nous le laissons de côté. Le calcul de la
norme L1 pour les modèles 1 et 2 est le suivant.
Rappelons que les équations des modèles sont les suivantes :
Modèle 1 : yˆ = 2x3 + 1,4x7 - 0,5x7 + 8
 Une autre alternative pour éviter l'overfitting : 93
Régularisation
Modèle 2 : yˆ = 22x1 - 103x2 - 14x3 + 109x4 - 93x5 + 203x6 + 87x7 - 55x8 + 378x9 - 25x10 + 8
94 I
Chapitre 4 Optimisation du processus de formation : Sous-assignation, sur-assignation, test et
régularisation

Norme L1 :
• Modèle 1 : |2| + |1.4| + |-0.5| = 3.9
• Modèle 2 : |22| + |-103| + |-14| + |109| + |-93| + |203| + |87| + |-55| + |378| + |-25| = 1 089
norme L2 :
• Modèle 1 : 22 + 1,42 + (-0,5)2 = 6,21
• Modèle 2 : 222 + (-103)2 + (-14)2 + 1092 + (-93)2 + 2032 + 872 + (-55)2 + 3782 + (-25)2 = 227 131
Comme prévu, les normes L1 et L2 du modèle 2 sont beaucoup plus grandes que les normes
correspondantes du modèle 1.
Les normes L1 et L2 peuvent également être calculées sur des polynômes en prenant soit la
somme des valeurs abso- lues, soit la somme des carrés des coefficients, à l'exception du
coefficient constant. Revenons à l'exemple du début de ce chapitre, où nos trois modèles étaient
un polynôme de degré 1 (une droite), de degré 2 (une parabole) et de degré 10 (une courbe qui
oscille 9 fois). Imaginez que leurs formules soient les suivantes :
• Modèle 1 : yˆ = 2x + 3
• Modèle 2 : yˆ = -x2 + 6x - 2
• Modèle 3 : yˆ = x9 + 4x8 - 9x7 + 3x6 - 14x5 - 2x4 - 9x3 + x2 + 6x + 10
Les normes L1 et L2 sont calculées comme suit :
Norme L1 :
• Modèle 1 : |2| = 2
• Modèle 2 : |-1| + |6| = 7
• Modèle 3 : |1| + |4| + |-9| + |3| + |-14| + |-2| + |-9| + |1| + |6| = 49
norme L2 :
• Modèle 1 : 22 = 2
• Modèle 2 : (-1)2 + 62 = 37
• Modèle 3 : 12 + 42 + (-9)2 + 32 + (-14)2 + (-2)2 + (-9)2 + 12 + 62 = 425
Maintenant que nous disposons de deux moyens de mesurer la complexité des modèles, nous allons
entamer le processus de formation.

Modifier la fonction d'erreur pour résoudre notre problème :

régression Lasso et régression ridge
Maintenant que nous avons fait le plus gros du travail, nous allons entraîner un modèle de
régression linéaire en utilisant la régu- lisation. Nous avons deux mesures pour notre modèle :
une mesure de performance (la fonction d'erreur) et une mesure de complexité (la norme L1 ou
L2).
 Une autre alternative pour éviter l'overfitting : 95
Régularisation

Rappelons que dans l'analogie du couvreur, notre objectif était de trouver un couvreur offrant à
la fois une bonne qualité et une faible complexité. Pour ce faire, nous avons minimisé la somme de
deux nombres : la mesure de la qualité et la mesure de la complexité. La régularisation consiste
à appliquer le même principe à notre modèle d'apprentissage automatique. Pour cela, nous
avons deux quantités : l'erreur de régression et le terme de régularisation.

erreur de régressionUne mesure de la qualité du modèle. Dans ce cas, il peut s'agir des
erreurs absolues ou carrées que nous avons apprises au chapitre 3.

terme de régularisationUne mesure de la complexité du modèle. Il peut s'agir de la

norme L1 ou L2 du modèle.

La quantité que nous voulons minimiser pour trouver un bon modèle pas trop complexe est
l'erreur modérée, définie comme la somme des deux, comme indiqué ci-dessous :
Erreur = erreur de régression + terme de régularisation
La régularisation est si courante que les modèles eux-mêmes portent des noms différents en
fonction de la norme utilisée. Si nous entraînons notre modèle de régression en utilisant la norme
L1, le modèle est appelé régression lasso. Lasso est l'abréviation de "least absolute shrinkage
and selection operator". La fonction d'erreur est la suivante :
Erreur de régression Lasso = Erreur de régression + norme L1

Si, au contraire, nous entraînons le modèle en utilisant la norme L2, on parle de régression
ridge. Le nom de crête vient de la forme de la fonction d'erreur, car l'ajout du terme de la
norme L2 à la fonction d'erreur de la régression transforme un angle aigu en une vallée lisse
lorsque nous la traçons. La fonction d'erreur est la suivante :
Erreur de régression de crête = erreur de régression + norme L2

Le lasso et la régression ridge fonctionnent bien dans la pratique. La décision d'utiliser l'une ou
l'autre dépend de certaines préférences que nous allons découvrir dans les sections suivantes.
Mais avant d'en arriver là, nous devons régler certains détails pour nous assurer que nos
modèles régularisés fonctionnent bien.
Régularisation du niveau de performance et de complexité de notre
modèle : Le paramètre de régularisation
Étant donné que le processus d'apprentissage du modèle consiste à réduire la fonction de
coût autant que possible, un modèle entraîné avec régularisation devrait, en principe, être
très performant et peu complexe. Cependant, il y a un certain tiraillement : essayer
d'améliorer les performances du modèle peut le rendre plus complexe, alors qu'essayer de
réduire la complexité du modèle peut le rendre moins performant. Heureusement, la plupart
des techniques d'apprentissage automatique sont accompagnées de boutons
(hyperparamètres) que le spécialiste des données peut tourner pour construire les meilleurs
modèles possibles, et la régularisation ne fait pas exception. Dans cette section, nous voyons
comment utiliser un hyperparamètre pour réguler entre performance et complexité.
96 I
Chapitre 4 Optimisation du processus de formation : Sous-assignation, sur-assignation, test et
régularisation

Cet hyperparamètre est appelé paramètre de régularisation, et son objectif est de

déterminer si le processus de formation du modèle doit privilégier la performance ou la
simplicité. Le paramètre de régularisation est désigné par , la lettre grecque lambda. Nous
multiplions le terme de régularisation par , nous l'ajoutons à l'erreur de régression et nous utilisons
ce résultat pour entraîner notre modèle. La nouvelle erreur devient la suivante :

Erreur = erreur de régression + terme de régularisation

Choisir une valeur de 0 pour annule le terme de régularisation, et nous nous retrouvons donc avec
le même modèle de régression que celui du chapitre 3. En choisissant une valeur élevée pour ,
on obtient un modèle simple, peut-être de faible degré, qui peut ne pas s'adapter très bien à
notre ensemble de données. Il est crucial de choisir une bonne valeur pour
et pour cela, la validation est une technique utile. Il est typique de choisir des puissances de
10, telles que 10, 1, 0,1, 0,01, mais ce choix est quelque peu arbitraire. Parmi celles-ci, nous
sélectionnons celle qui rend notre modèle le plus performant dans notre ensemble de
validation.

Effets de la régularisation L1 et L2 dans les coefficients du modèle

Dans cette section, nous verrons les différences cruciales entre les régularisations L1 et L2 et
nous aurons quelques idées sur celle à utiliser dans différents scénarios. À première vue, elles
semblent similaires, mais les effets qu'elles ont sur les coefficients sont intéressants et, selon
le type de modèle que nous voulons, le choix entre l'utilisation de la régularisation L1 et L2
peut être critique.
Revenons à notre exemple de recommandation de films, où nous construisons un modèle
de régression pour prédire le temps (en secondes) pendant lequel un utilisateur regardera un
film, compte tenu du temps pendant lequel ce même utilisateur a regardé 10 films différents.
Imaginons que nous ayons entraîné le modèle et que l'équation obtenue soit la suivante :
Modèle : yˆ = 22x1 - 103x2 - 14x3 + 109x4 - 93x5 + 203x6 + 87x7 - 55x8 + 378x9 - 25x10 + 8
Si nous ajoutons une régularisation et entraînons à nouveau le modèle, nous obtenons un
modèle plus simple. Les deux propriétés suivantes peuvent être démontrées
mathématiquement :
• Si nous utilisons la régularisation L1 (régression lasso), vous obtenez un modèle avec
moins de coefficients. En d'autres termes, la régularisation L1 transforme certains
des coefficients en zéro. Ainsi, nous pouvons nous retrouver avec une équation
comme yˆ = 2x3 + 1,4x7 - 0,5x9 + 8.
• Si nous utilisons la régularisation L2 (régression ridge), nous obtenons un modèle avec
des coefficients plus petits. En d'autres termes, la régularisation L2 réduit tous les
coefficients mais les transforme rarement en zéro. Ainsi, nous pouvons nous retrouver
avec une équation comme yˆ = 0,2x1 - 0,8x2 - 1,1x3 + 2,4x4 - 0,03x5 + 1,02x6 + 3,1x7 - 2x8 +
2,9x9 - 0,04x10 + 8.
Ainsi, en fonction du type d'équation que nous voulons obtenir, nous pouvons décider d'utiliser
la régularisation L1 ou L2.
Voici une règle empirique rapide à utiliser pour décider si l'on veut utiliser la régularisation
 Une autre alternative pour éviter l'overfitting : 97
Régularisation
L1 ou L2 : si l'on a trop de caractéristiques et que l'on souhaite se débarrasser de la plupart d'entre
elles, la régularisation L1 est parfaite pour cela. Si nous n'avons que quelques caractéristiques et
que nous pensons qu'elles sont toutes pertinentes, alors la régularisation L2 est ce qu'il nous
faut, car elle ne se débarrassera pas de nos caractéristiques utiles.
98 I
Chapitre 4 Optimisation du processus de formation : Sous-assignation, sur-assignation, test et
régularisation

Le système de recommandation de films que nous avons étudié dans la section " Un autre
exemple d'ajustement excessif " est un exemple de problème dans lequel nous avons de
nombreuses caractéristiques et où la régularisation L1 peut nous aider : Recommandations de
films". Dans ce modèle, chaque caractéristique correspond à l'un des films, et notre objectif est
de trouver les quelques films qui sont liés à celui qui nous intéresse. Ainsi, nous avons besoin d'un
modèle pour lequel la plupart des coefficients sont nuls, à l'exception de quelques-uns d'entre
eux.
Un exemple dans lequel nous devrions utiliser la régularisation L2 est l'exemple polynomial
au débutdela section "Un exemple de sous-adaptation à l'aide de la régression polynomiale". Pour ce
modèle, nous n'avions qu'une seule caractéristique : x. La régularisation L2 nous donnerait un
bon modèle polynomial avec de petits coefficients, qui n'oscillerait pas beaucoup et serait
donc moins sujet à l'overfitting. Dans la section "Régression polynomiale, test et régularisation
avec Turi Create", nous verrons un exemple poly- nomial pour lequel la régularisation L2 est la
bonne à utiliser.
Les ressources correspondant à ce chapitre (annexe C) indiquent quelques endroits où vous
pouvez approfondir les raisons mathématiques pour lesquelles la régularisation L1 transforme
les coefficients en zéro, alors que la régularisation L2 les transforme en petits nombres. Dans la
section suivante, nous apprendrons comment en avoir l'intuition.
Une façon intuitive de voir la régularisation
Dans cette section, nous apprenons comment les normes L1 et L2 diffèrent dans leur façon de
pénaliser la complexité. Cette section est essentiellement intuitive et est développée dans un
exemple, mais si vous souhaitez voir les mathématiques formelles qui les sous-tendent, veuillez
consulter l'annexe B, "Utilisation de la descente de gradient pour la régularisation". Lorsque nous
essayons de comprendre le fonctionnement d'un modèle d'apprentissage automatique, nous
devons regarder au-delà de la fonction d'erreur. Une fonction d'erreur dit : "Voici l'erreur, et si
vous la réduisez, vous obtenez un bon modèle". Mais cela revient à dire : "Le secret pour
réussir dans la vie est de faire le moins d'erreurs possible." Un message positif n'est-il pas
préférable, comme "Voici les choses que vous pouvez faire pour améliorer votre vie", par
opposition à "Voici les choses que vous devriez éviter" ? Voyons voir la régularité...
tion de cette manière.
Au chapitre 3, nous avons appris les astuces de l'absolu et du carré, qui nous donnent un
aperçu plus clair de la régression. À chaque étape du processus d'apprentissage, nous choisissons
simplement un point (ou plusieurs points) et rapprochons la ligne de ces points. En répétant ce
processus de nombreuses fois, on finit par obtenir un bon ajustement de la ligne. Nous pouvons
être plus précis et répéter comment nous avons défini l'algorithme de régression linéaire au
chapitre 3.
Pseudocode de l'algorithme de régression linéaire
Entrées : Un ensemble de données de points
Sorties : Un modèle de régression linéaire qui s'adapte à cet ensemble de données.
Procédure :
• Choisissez un modèle avec des poids aléatoires et un biais aléatoire.
 Une autre alternative pour éviter l'overfitting : 99
Régularisation
• Répétez plusieurs fois :
– Choisissez un point de données au hasard.
– Ajustez légèrement les pondérations et le biais pour améliorer la prédiction pour ce point
de données.
• Profitez de votre modèle !
100 I
Chapitre 4 Optimisation du processus de formation : Sous-assignation, sur-assignation, test et
régularisation

Peut-on utiliser le même raisonnement pour comprendre la régularisation ? Oui, nous le pouvons.
Pour simplifier les choses, disons que nous sommes au milieu de notre formation et que nous
voulons rendre le modèle plus simple. Nous pouvons le faire en réduisant les coefficients. Pour
simplifier, disons que notre modèle a trois coefficients : 3, 10 et 18. Pouvons-nous faire un petit
pas pour diminuer ces trois coefficients d'une petite quantité ? Bien sûr que oui, et voici deux
méthodes pour le faire. Toutes deux nécessitent un petit nombre, , que nous fixerons à 0,01
pour l'instant.
Méthode 1 : Soustrayez de chacun des paramètres positifs, et ajoutez à chacun des
paramètres négatifs. S'ils sont nuls, ne les touchez pas.
Méthode 2 : Multipliez-les tous par 1 - . Remarquez que ce nombre est proche de 1, car il est petit.
En utilisant la méthode 1, nous obtenons les nombres 2,99, 9,99 et 17,99.
En utilisant la méthode 2, nous obtenons les nombres 2,97, 9,9 et 17,82.
Dans ce cas, se comporte très bien comme un taux d'apprentissage. En fait, il est étroitement
lié au taux de régularisation (voir "Utilisation de la descente de gradient pour la régularisation" à
l'annexe B pour plus de détails). Remarquez que dans les deux méthodes, nous réduisons la
taille des coefficients. Maintenant, tout ce que nous avons à faire est de réduire de façon
répétée les coefficients à chaque étape de l'algorithme. En d'autres termes, voici comment nous
formons le modèle maintenant :
Entrées : Un ensemble de données de points
Sorties : Un modèle de régression linéaire qui s'adapte à cet ensemble de données.
Procédure :
• Choisissez un modèle avec des poids aléatoires et un biais aléatoire.
• Répétez plusieurs fois :
– Choisissez un point de données au hasard.
– Ajustez légèrement les pondérations et le biais afin d'améliorer la prédiction pour
ce point de données particulier.
– Réduisez légèrement les coefficients en utilisant la méthode 1 ou la méthode 2.
• Profitez de votre modèle !
Si nous utilisons la méthode 1, nous entraînons le modèle avec une régularisation L1, ou
régression lasso. Si nous utilisons la méthode 2, nous entraînons le modèle avec une
régularisation L2, ou régression ridge. Il existe une justification mathématique à cela, qui est décrite
dans l'annexe B, "Utilisation de la descente de gradient pour la régularisation".
Dans la section précédente, nous avons appris que la régularisation L1 tend à transformer de
nombreux coefficients en 0, tandis que la régularisation L2 tend à les diminuer mais pas à les
transformer en zéro. Ce phénomène est maintenant plus facile à voir. Disons que notre
coefficient est 2, avec un paramètre de régularisation de
= 0.01. Remarquez ce qui se passe si nous utilisons la méthode 1 pour réduire notre
 Une autre alternative pour éviter l'overfitting : 101
Régularisation
coefficient, et que nous répétons ce processus 200 fois. Nous obtenons la séquence de valeurs
suivante :
2 .99 .98 02 .01 0
 Régression polynomiale, test et régularisation avec Turi Create 95

Après 200 époques de notre apprentissage, le coefficient devient 0, et il ne change plus jamais.
Voyons maintenant ce qui se passe si nous appliquons la méthode 2, à nouveau 200 fois et avec le
même taux d'apprentissage de h = 0,01. Nous obtenons la séquence de valeurs suivante :
2 .98 .9602 2734 .2707 .2680
Remarquez que le coefficient a considérablement diminué, mais qu'il n'est pas devenu nul. En
fait, quel que soit le nombre d'époques que nous exécutons, le coefficient ne deviendra jamais
nul. En effet, lorsque nous multiplions un nombre non négatif par 0,99 plusieurs fois, ce
nombre ne devient jamais nul. Ceci est illustré à la figure 4.7.

Régularisation L1 Régularisation L2

Figure 4.7 L1 et L2 réduisent toutes deux la taille du coefficient. La régularisation L1 (à gauche) le fait beaucoup
plus rapidement, car elle soustrait une quantité fixe, de sorte qu'il est probable qu'elle finisse par devenir nulle.
La régularisation L2 prend beaucoup plus de temps, car elle multiplie le coefficient par un petit facteur, de sorte
qu'il n'atteint jamais zéro.

Régression polynomiale, tests et régularisation avec

Turi Create
Dans cette section, nous voyons un exemple de régression polynomiale avec régularisation
dans Turi Create. Voici le code de cette section :
• Carnet de notes :
– https://github.com/luisguiserrano/manning/blob/master/Chapter_4_Testing_
Overfitting_Underfitting/Polynomial_regression_regularization.ipynb
Nous commençons par notre ensemble de données, illustré à la figure 4.8. Nous pouvons voir que la
courbe qui correspond le mieux à ces données est une parabole qui s'ouvre vers le bas (un visage
96 Chapitre 4 I Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
triste). Il ne s'agit donc pas d'un problème que nous pouvons résoudre
régularisation
 Régression polynomiale, test et régularisation avec Turi Create 97

avec la régression linéaire - nous devons utiliser la régression polynomiale. L'ensemble de

données est stocké dans un SFrame appelé data, et les premières lignes sont présentées dans
le tableau 4.1.

Figure 4.8 L'ensemble de données. Remarquez que sa forme est une parabole qui s'ouvre vers le bas, de sorte
que l'utilisation de la régression linéaire ne fonctionnera pas bien. Nous utiliserons la régression polynomiale
pour ajuster cet ensemble de données, et nous utiliserons la régularisation pour ajuster notre modèle.

Tableau 4.1 Les quatre premières lignes de notre jeu de données

x y
3.4442185152504816 6.685961311021467
-2.4108324970703663 4.690236225597948
0.11274721368608542 12.205789026637378
-1.9668727392107255 11.133217991032268

La façon d'effectuer une régression polynomiale dans Turi Create est d'ajouter de nombreuses
colonnes à notre ensemble de données, correspondant aux puissances de la caractéristique
principale, et d'appliquer une régression linéaire à cet ensemble de données élargi. Si la
caractéristique principale est, disons, x, alors nous ajoutons des colonnes avec les valeurs de x2 , x3 ,
x4 , et ainsi de suite. Ainsi, notre modèle trouve des combinaisons linéaires des puissances de x,
qui sont précisément des polynômes de x. Si le SFrame contenant nos données est appelé
data, nous utilisons le code suivant pour ajouter des colonnes pour les puissances jusqu'à x199
. Les premières lignes et colonnes de l'ensemble de données résultant apparaissent dans le
tableau 4.2.
for i in range(2,200) :
string = 'x^'+str(i)
98 I
Chapitre 4 Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
régularisation
data[string] = data['x'].apply(lambda x:x**i)
 Régression polynomiale, test et régularisation avec Turi Create 99

Tableau 4.2 Les quatre premières lignes et les cinq colonnes les plus à gauche de notre jeu de
données. La colonne étiquetée x^k correspond à la variable x^k, pour k = 2, 3 et 4. L'ensemble
de données comporte 200 colonnes.
x y x^2 x^3 x^4
3.445 6.686 11.863 40.858 140.722
-2.411 4.690 5.812 -14.012 33.781
0.113 12.206 0.013 0.001 0.000
-1.967 11.133 3.869 -7.609 14.966

Maintenant, nous appliquons la régression linéaire à ce grand ensemble de données de 200

colonnes. Remarquez qu'un modèle de régression linéaire dans cet ensemble de données
ressemble à une combinaison linéaire des variables dans les colonnes. Mais comme chaque
colonne correspond à un monôme, le modèle obtenu ressemble alors à un poly- nomal sur la
variable x.
Avant de former des modèles, nous devons diviser les données en ensembles de données de
formation et de test, en utilisant la ligne de code suivante :

train, test = data.random_split(.8)

Maintenant, notre jeu de données est divisé en deux jeux de données, le jeu d'entraînement
appelé train et le jeu de test appelé test. Dans le référentiel, une graine aléatoire est spécifiée,
afin que nous obtenions toujours les mêmes résultats, bien que cela ne soit pas nécessaire en
pratique.
La façon d'utiliser la régularisation dans Turi Create est simple : tout ce que nous devons
faire est de spécifier les paramètres l1_pénalité et l2_pénalité dans la méthode create
lorsque nous formons le modèle. Cette pénalité est précisément le paramètre de régularisation que
nous avons introduit dans la section "Réguler le niveau de performance et de complexité de
notre modèle." Une pénalité de 0 signifie que nous n'utilisons pas de régularisation. Ainsi,
nous allons entraîner trois modèles différents avec les paramètres suivants :
• Pas de modèle de régularisation :
– l1_pénalité=0
– l2_pénalité=0
• Modèle de régularisation L1 :
– l1_pénalité=0.1
– l2_pénalité=0
• Modèle de régularisation L2 :
– l1_pénalité=0
– l2_pénalité=0.1
100 Chapitre 4 I Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
Nous régularisation
formons les modèles avec les trois lignes de code suivantes :
 Régression polynomiale, test et régularisation avec Turi Create 101

modèle_no_reg = tc.linear_regression.create(train, target='y', l1_penalty=0.0,

l2_penalty=0.0)
modèle_L1_reg = tc.linear_regression.create(train, target='y', l1_penalty=0.1,
l2_penalty=0.0)
model_L2_reg = tc.linear_regression.create(train, target='y', l1_penalty=0.0,
l2_penalty=0.1)

Le premier modèle n'utilise aucune régularisation, le deuxième utilise la régularisation L1 avec

un paramètre de 0,1, et le troisième utilise la régularisation L2 avec un paramètre de 0,1. Les
tracés des fonctions résultantes sont présentés à la figure 4.9. Notez que dans cette figure, les
points de l'ensemble d'apprentissage sont des cercles, et ceux de l'ensemble de test sont des
triangles.

Pas de Régularisation L1 Régularisation L2

régularisation

RMSE de test : RMSE de test : 10.08 RMSE de test : 3.41

699.03

Figure 4.9 Trois modèles de régression polynomiale pour notre ensemble de données. Le modèle de gauche
n'a pas de régularisation, le modèle du milieu a une régularisation L1 avec un paramètre de 0,1, et le modèle
de droite a une régularisation L2 avec un paramètre de 0,1.

Remarquez que le modèle sans régularisation s'adapte très bien aux points d'apprentissage,
mais qu'il est chaotique et ne s'adapte pas bien aux points de test. Le modèle avec
régularisation L1 s'en sort bien à la fois avec les ensembles d'apprentissage et de test. Mais le
modèle avec régularisation L2 fait un travail formidable à la fois avec les ensembles
d'apprentissage et de test et semble également être celui qui capture vraiment la forme des
données.
Notez également que pour les trois modèles, la courbe limite s'affole un peu sur les points
extrêmes. Cela est tout à fait compréhensible, car les points d'extrémité comportent moins de
données et il est naturel que le modèle ne sache pas quoi faire en l'absence de données. Nous
devrions toujours évaluer les modèles en fonction de leurs performances à l'intérieur des limites
de notre ensemble de données, et nous ne devrions jamais attendre d'un modèle qu'il soit
performant en dehors de ces limites. Même nous, les humains, pouvons ne pas être capables de
faire de bonnes prédictions en dehors des limites du modèle. Par exemple, comment pensez-
vous que cette courbe se présenterait en dehors de l'ensemble de données ? Continuerait-elle
comme une parabole qui s'ouvre vers le bas ? Oscillerait-elle éternellement comme une
fonction sinus ? Si nous ne le savons pas, nous ne devons pas nous attendre à ce que le
modèle le sache. Ainsi, essayez d'ignorer le comportement étrange des points d'extrémité de la
figure 4.9, et concentrez-vous sur le comportement du modèle à l'intérieur de l'intervalle où se
102 trouvent I Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
les 4données.
Chapitre
Pour
régularisation l'erreur de test, nous utilisons la ligne de code suivante, avec le nom
trouver
correspondant du modèle. Cette ligne de code renvoie l'erreur maximale et l'erreur quadratique
moyenne (RMSE).
modèle.predict(test)
 Régression polynomiale, test et régularisation avec Turi Create 103

Les RMSE de test pour les modèles sont les suivants :

• Modèle sans régularisation : 699.03
• Modèle avec régularisation L1 : 10.08
• Modèle avec régularisation L2 : 3.41

Le modèle sans régularisation avait un RMSE vraiment important ! Parmi les deux autres
modèles, celui avec régularisation L2 était beaucoup plus performant. Voici deux questions
auxquelles vous devez réfléchir :
1. Pourquoi le modèle avec régularisation L2 a-t-il été plus performant que celui
avec régularisation L1 ?
2. Pourquoi le modèle avec la régularisation L1 semble-t-il plat, alors que le
modèle avec la régularisation L2 parvient à capturer la forme des données ?
Les deux questions ont une réponse similaire, et pour la trouver, nous pouvons regarder les
coefficients des polynômes. Ceux-ci peuvent être obtenus avec la ligne de code suivante :

coefficients.du.modèle

Chaque polynôme a 200 coefficients, nous ne les afficherons donc pas tous ici, mais dans le
tableau 4.3, vous pouvez voir les cinq premiers coefficients des trois modèles. Que remarquez-
vous ?

Tableau 4.3 Les cinq premiers coefficients des polynômes de nos trois modèles. Notez que le
modèle sans régularisation a de grands coefficients, le modèle avec régularisation L1 a des
coefficients très proches de 0, et le modèle avec régularisation L2 a de petits coefficients.

Coefficient modèle_no_re modèle_L1_re modèle_L2_re

g g g
x0 = 1 8.41 0.57 13.24
x1 15.87 0.07 0.87
x2 108.87 -0.004 -0.52
x3 -212.89 0.0002 0.006
x4 -97.13 -0.0002 -0.02

Pour interpréter le tableau 4.3, nous voyons que les prédictions des trois modèles sont des
polynômes de degré 200. Les premiers termes se présentent comme suit :
• Modèle sans régularisation : yˆ = 8,41 + 15,87x + 108,87x2 - 212,89x3 - 97,13x4 + ....
• Modèle avec régularisation L1 : yˆ = 0,57 + 0,07x - 0,004x2 + 0,0002x3 - 0,0002x4 + ....
• Modèle avec régularisation L2 : yˆ = 13,24 + 0,87x - 0,52x2 + 0,006x3 - 0,02x4 + ....
104 I
Chapitre 4 Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
régularisation

A partir de ces polynômes, nous voyons ce qui suit :

• Pour le modèle sans régularisation, tous les coefficients sont grands. Cela signifie
que le polynôme est chaotique et qu'il n'est pas bon pour faire des prédictions.
• Pour le modèle avec régularisation L1, tous les coefficients, sauf le coefficient constant
(le premier), sont minuscules - presque 0. Cela signifie que pour les valeurs proches de
zéro, le polynôme ressemble beaucoup à la ligne horizontale avec l'équation yˆ = 0,57.
C'est mieux que le modèle précédent mais ce n'est toujours pas génial pour faire des
prédictions.
• Pour le modèle avec régularisation L2, les coefficients deviennent plus petits au fur et à
mesure que le degré augmente mais ne sont toujours pas si petits. Cela nous donne un
polynôme décent pour faire des prédictions.

Résumé
• Lorsqu'il s'agit de former des modèles, de nombreux problèmes se posent. Les deux
problèmes qui reviennent le plus souvent sont l'underfitting et l'overfitting.
• Il y a sous-adaptation lorsque nous utilisons un modèle très simple pour ajuster
notre ensemble de données. Un ajustement excessif se produit lorsque nous
utilisons un modèle trop complexe pour ajuster notre ensemble de données.
• Un moyen efficace de distinguer l'overfitting de l'underfitting est d'utiliser un ensemble de
données de test.
• Pour tester un modèle, nous divisons les données en deux ensembles : un ensemble de
formation et un ensemble de test. L'ensemble d'entraînement est utilisé pour former le
modèle, et l'ensemble de test est utilisé pour évaluer le modèle.
• La règle d'or de l'apprentissage automatique est de ne jamais utiliser nos
données de test pour former ou prendre des décisions dans nos modèles.
• L'ensemble de validation est une autre partie de notre ensemble de données que nous
utilisons pour prendre des décisions sur les hyperparamètres de notre modèle.
• Un modèle qui ne s'adapte pas aura de mauvaises performances dans l'ensemble
d'apprentissage et dans l'ensemble de validation. Un modèle qui s'adapte trop bien
aura de bonnes performances dans l'ensemble d'apprentissage mais de mauvaises
performances dans l'ensemble de validation. Un bon modèle sera performant à la fois
dans l'ensemble d'apprentissage et dans l'ensemble de validation.
• Le graphique de complexité du modèle est utilisé pour déterminer la complexité
correcte d'un modèle, afin qu'il ne soit ni sous-adapté ni sur-adapté.
• La régularisation est une technique très importante pour réduire l'overfitting dans les
modèles d'apprentissage automatique. Elle consiste à ajouter une mesure de
complexité (terme de régularisation) à la fonction d'erreur pendant le processus de
 Régression polynomiale, test et régularisation avec Turi Create 105
formation.
• Les normes L1 et L2 sont les deux mesures de complexité les plus courantes
utilisées dans la régularisation.
• L'utilisation de la norme L1 conduit à la régularisation L1, ou régression lasso.
L'utilisation de la norme L2 conduit à la régularisation L2, ou à la régression ridge.
106 I
Chapitre 4 Optimisation du processus de formation : Sous-adaptation, sur-adaptation, test et
régularisation

• La régularisation L1 est recommandée lorsque notre jeu de données comporte de

nombreuses caractéristiques et que nous voulons en réduire un grand nombre à zéro. La
régularisation L2 est recommandée lorsque notre jeu de données comporte peu de
caractéristiques et que nous voulons les rendre petites mais pas nulles.

Exercices
Exercice 4.1
Nous avons entraîné quatre modèles dans le même ensemble de données avec différents
hyperparamètres. Dans le tableau suivant, nous avons enregistré les erreurs d'entraînement et
de test pour chacun des modèles.

Modèl Erreur de Erreur de test

e formation
1 0.1 1.8
2 0.4 1.2
3 0.6 0.8
4 1.9 2.3

a. Quel modèle choisiriez-vous pour cet ensemble de données ?

b. Quel modèle semble sous-adapter les données ?
c. Quel modèle a l'air de trop s'adapter aux données ?

Exercice 4.2
On nous donne l'ensemble de données suivant :

x y
1 2
2 2.5
3 6
4 14.5
5 34

Nous formons le modèle de régression polynomial qui prédit la valeur de y comme yˆ, où
yˆ = 2x2 - 5x + 4.
Si le paramètre de régularisation est = 0,1 et que la fonction d'erreur que nous avons utilisée
pour former cet ensemble de données est la valeur absolue moyenne (MAE), déterminez ce qui
suit :
 Exercices 101
a. L'erreur de régression lasso de notre modèle (en utilisant la norme L1)
b. L'erreur de régression ridge de notre modèle (en utilisant la norme L2)