Aller au contenu
Data science

Sous-apprentissage et surapprentissage

⏱ 1 h

Prérequis : La régression linéaire et la descente de gradient · Mesurer une régression

À la fin de ce chapitre, vous saurez :
  • distinguer l'erreur d'entraînement de l'erreur de test, et dire laquelle compte ;
  • reconnaître le sous-apprentissage et le surapprentissage, sur une courbe et sur des chiffres ;
  • expliquer le compromis entre biais et variance ;
  • citer et mettre en œuvre quatre remèdes : plus de données, régularisation, validation croisée, arrêt précoce.

Imaginez deux étudiants qui préparent un examen avec les annales des années précédentes.

  • Le premier apprend par cœur les réponses. Sur les annales, il obtient 20/20.
  • Le second cherche à comprendre les méthodes. Sur les annales, il fait quelques erreurs.

Le jour de l’examen, les questions sont nouvelles. Le premier est perdu ; le second s’en sort. Un modèle d’apprentissage automatique peut, lui aussi, apprendre par cœur au lieu de comprendre : c’est le surapprentissage (en anglais overfitting). À l’inverse, un modèle trop simple ne comprend même pas les annales : c’est le sous-apprentissage (underfitting).

Tout l’art du métier consiste à trouver le juste milieu. Ce chapitre explique comment le voir, le mesurer et le corriger.

Prenons un problème simple : des points (x,y)(x, y) où yy suit une courbe (une sinusoïde, en vert pointillé), plus un peu de bruit. On ne connaît que les points ; on cherche une fonction qui prédit yy à partir de xx. Ici, le modèle est un polynôme, et son degré règle sa complexité : degré 1, une droite ; degré 3, une courbe qui peut onduler un peu ; degré 15, une courbe très souple.

On mesure l’erreur d’un modèle par l’erreur quadratique moyenne (MSE) : la moyenne des carrés des écarts entre prédictions et vraies valeurs. On la calcule à deux endroits :

  • sur les points qui ont servi à ajuster le modèle (● bleus) : l’erreur d’entraînement ;
  • sur des points jamais vus pendant l’ajustement (○ orange) : l’erreur de test.

Essayez les degrés 1, 3 et 15 :

Degré Ce qu’on voit Erreur d’entraînement Erreur de test Diagnostic
1 une droite, incapable de suivre la courbe grande grande sous-apprentissage
3 à 5 une courbe proche de la vraie fonction petite petite bon modèle
15 une courbe qui passe par presque tous les points bleus et s’envole entre eux quasi nulle énorme surapprentissage

Le bruit fixe une limite : même la vraie fonction se trompe d’environ σ2\sigma^2 (le carré de l’écart-type du bruit) en moyenne. Une erreur d’entraînement inférieure au bruit est donc suspecte : le modèle a appris le hasard.

Traçons les deux erreurs pour chaque degré possible. Le résultat a toujours la même allure :

  • À gauche, les deux erreurs sont grandes : le modèle est trop rigide.
  • Au milieu, l’erreur de test atteint son minimum : c’est le meilleur compromis.
  • À droite, l’erreur d’entraînement continue de baisser, mais l’erreur de test remonte : le modèle apprend le bruit.

Cliquez sur 🎲 Autre tirage plusieurs fois : la forme en U reste, mais le meilleur degré change un peu. Avec si peu de points, le hasard compte beaucoup.

🔬La même expérience dans le simulateur de régression

Polynôme, arbre, kNN, SVR, réseau : le curseur de complexité et la courbe en U pour chaque modèle.

→

Pourquoi un modèle trop complexe se trompe-t-il ? Pour le comprendre, imaginons qu’on puisse refaire l’expérience de nombreuses fois, avec à chaque fois un nouveau jeu de données tiré de la même façon. Chaque entraînement donne un modèle un peu différent. Deux défauts peuvent apparaître :

  • le biais : en moyenne, les modèles sont à côté de la vérité. Le modèle est trop simple pour la représenter ;
  • la variance : les modèles changent beaucoup d’un jeu de données à l’autre. Le modèle est si souple qu’il épouse les particularités (le bruit) de chaque échantillon.

L’image classique est celle des fléchettes :

Faisons-le vraiment : 30 jeux de 30 points, un polynôme ajusté sur chacun.

  • Degré 0 ou 1 : toutes les courbes se ressemblent (variance faible), mais leur moyenne est loin de la vraie fonction (biais fort).
  • Degré 10 ou plus : en moyenne, les courbes suivent bien la vraie fonction (biais faible), mais chacune part dans tous les sens (variance forte).
  • Le graphique de droite montre le compromis : le biais baisse et la variance monte avec la complexité ; leur somme est minimale au milieu.
🎓 Pour aller plus loin : la décomposition biais-variance

Notons y=f(x)+εy = f(x) + \varepsilon avec E[ε]=0\mathbb{E}[\varepsilon] = 0 et Var⁡(ε)=σ2\operatorname{Var}(\varepsilon) = \sigma^2, et f^D\hat f_D le modèle appris sur un jeu de données DD tiré au hasard. Pour un point xx fixé, l’erreur attendue sur un nouvel exemple, en moyenne sur les jeux de données possibles, se décompose exactement :

ED,ε ⁣[(y−f^D(x))2]=(f(x)−ED[f^D(x)])2⏟biais2+ED ⁣[(f^D(x)−ED[f^D(x)])2]⏟variance+σ2⏟bruit.\mathbb{E}_{D,\varepsilon}\!\left[\big(y - \hat f_D(x)\big)^2\right] = \underbrace{\big(f(x) - \mathbb{E}_D[\hat f_D(x)]\big)^2}_{\text{biais}^2} + \underbrace{\mathbb{E}_D\!\left[\big(\hat f_D(x) - \mathbb{E}_D[\hat f_D(x)]\big)^2\right]}_{\text{variance}} + \underbrace{\sigma^2}_{\text{bruit}} .

Démonstration. Notons fˉ(x)=ED[f^D(x)]\bar f(x) = \mathbb{E}_D[\hat f_D(x)]. On écrit y−f^D=ε+(f−fˉ)+(fˉ−f^D)y - \hat f_D = \varepsilon + (f - \bar f) + (\bar f - \hat f_D), puis on développe le carré. Les termes croisés sont nuls en espérance : ε\varepsilon est indépendant de DD et centré, f−fˉf - \bar f est une constante, et ED[fˉ−f^D]=0\mathbb{E}_D[\bar f - \hat f_D] = 0 par définition de fˉ\bar f. Il reste la somme des trois carrés.

Le bruit σ2\sigma^2 est irréductible : aucun modèle ne peut prédire le hasard. Le widget estime le biais² et la variance en remplaçant les espérances par des moyennes sur les 30 jeux de données, puis en moyennant sur xx.

Un modèle très souple a besoin de beaucoup d’exemples pour ne pas se laisser guider par le bruit. Gardons un polynôme de degré 12 et augmentons le nombre de points :

Avec 15 points, la courbe est délirante ; avec 300, elle colle à la vraie fonction. Plus il y a de données, plus on peut se permettre un modèle complexe. C’est l’une des raisons du succès de l’apprentissage profond : des modèles gigantesques, mais aussi des quantités énormes de données.

Quand on ne peut pas avoir plus de données, on peut pénaliser la complexité. Les polynômes qui oscillent follement ont de très grands coefficients ; la régularisation ajoute à l’erreur un terme qui les pénalise. Le modèle doit alors trouver un compromis entre « coller aux points » et « rester calme ».

  • λ=0\lambda = 0 : aucune pénalité, surapprentissage ;
  • λ\lambda moyen : la courbe se calme et l’erreur de test chute ;
  • λ\lambda trop grand : la courbe s’aplatit, c’est du sous-apprentissage.

La régularisation est partout : le paramètre C de la régression logistique et du SVM (qui vaut 1/λ1/\lambda), alpha de Ridge, Lasso et des réseaux de scikit-learn, le weight decay et le dropout des réseaux de neurones.

🎓 Pour aller plus loin : la régression Ridge

La régression Ridge minimise l’erreur quadratique plus la somme des carrés des coefficients :

w^=arg⁡min⁡w  1n∑i=1n(yi−xi⊤w)2+λ∥w∥22.\hat w = \arg\min_w \; \frac{1}{n}\sum_{i=1}^{n} \big(y_i - x_i^\top w\big)^2 + \lambda \lVert w \rVert_2^2 .

En annulant le gradient, on obtient une formule explicite :

w^=(X⊤X+nλI)−1X⊤y.\hat w = \big(X^\top X + n\lambda I\big)^{-1} X^\top y .

Ajouter nλIn\lambda I rend la matrice toujours inversible, et rétrécit les coefficients. Dans la base des vecteurs propres de X⊤XX^\top X (valeurs propres μj\mu_j), chaque composante de la solution sans régularisation est multipliée par μjμj+nλ\frac{\mu_j}{\mu_j + n\lambda} : les directions mal déterminées par les données (μj\mu_j petit), celles qui portent surtout le bruit, sont presque effacées.

Avec la pénalité λ∥w∥1\lambda \lVert w \rVert_1 (régression Lasso), certains coefficients deviennent exactement nuls : le modèle sélectionne aussi ses variables.

On a vu que le meilleur degré est celui qui minimise l’erreur de test. Mais si on choisit le degré en regardant le test, le test n’est plus « jamais vu » : son erreur devient optimiste. Le test doit servir une seule fois, à la toute fin.

La solution : la validation croisée. On coupe les données d’entraînement en kk parts (les plis). Chaque pli sert à son tour de validation, pendant qu’on entraîne le modèle sur les k−1k-1 autres. La moyenne des kk erreurs estime l’erreur de test, sans jamais toucher au test.

La courbe bleue (validation croisée) a la même forme que la courbe orange (le vrai test, inconnu en pratique) : elle permet de choisir le degré honnêtement. C’est ce que font cross_val_score et GridSearchCV dans scikit-learn.

🔬Fuite de données, dans la page Comparer

Lancez l’expérience « Fuite de données » : de combien le score annoncé est-il trop optimiste quand on règle un modèle sur le test ?

→

Les modèles entraînés par itérations (descente de gradient, réseaux de neurones, boosting) deviennent de plus en plus complexes au fil de l’entraînement. Au début, ils apprennent la forme générale des données ; ensuite, les détails ; enfin, le bruit. On peut donc les arrêter au bon moment : c’est l’arrêt précoce (early stopping).

Cliquez sur ▶ Entraîner : le polynôme de degré 12 commence plat, rejoint la sinusoïde vers quelques dizaines d’époques, puis se déforme pour passer par chaque point. L’erreur de validation (orange) forme à nouveau un U : on garde le modèle de son minimum. Dans Keras, c’est le rôle du callback EarlyStopping(monitor="val_loss", restore_best_weights=True).

🎓 Pour aller plus loin : pourquoi l'arrêt précoce régularise

Pour l’erreur quadratique, la descente de gradient partant de w0=0w_0 = 0 avec un taux η\eta se calcule exactement. Dans la base des vecteurs propres de A=1nX⊤XA = \frac1n X^\top X (valeurs propres μj\mu_j), la composante jj des poids après tt itérations vaut

wj(t)=(1−(1−η μj)t) wj⋆,w_j(t) = \Big(1 - (1 - \eta\,\mu_j)^t\Big)\, w_j^{\star},

où w⋆w^\star est la solution des moindres carrés. Les directions où μj\mu_j est grand (la forme générale, bien déterminée par les données) sont apprises en quelques itérations ; celles où μj\mu_j est minuscule (les détails fins, dominés par le bruit) demandent ∼1/(ημj)\sim 1/(\eta \mu_j) itérations, parfois des milliards. Arrêter tôt revient à effacer ces dernières, comme la régression Ridge, avec un filtre 1−(1−ημj)t1 - (1-\eta\mu_j)^t qui joue le rôle de μjμj+nλ\frac{\mu_j}{\mu_j + n\lambda}. C’est exactement ce calcul que fait le widget ci-dessus, ce qui lui permet d’aller jusqu’à 10910^9 époques instantanément.

Le polynôme n’est qu’un exemple. Chaque famille de modèles a son réglage de complexité : le nombre de voisins du kNN, la profondeur d’un arbre, γ et C d’un SVM, le nombre d’époques d’un réseau de neurones. Le vocabulaire change ; la courbe en U, jamais. Le chapitre Les modèles non linéaires en régression le montre pour quatre d’entre eux, et Choisir un modèle récapitule tous les réglages.

✅ Vérifiez vos acquis

1. Un modèle obtient 99 % de précision sur l'entraînement et 71 % sur le test. Que se passe-t-il le plus probablement ?
2. Un modèle obtient 62 % sur l'entraînement et 60 % sur le test, sur un problème où d'autres modèles atteignent 95 %. Que faire en priorité ?
3. Quand on augmente la complexité d'un modèle, l'erreur d'entraînement…
4. On augmente fortement la régularisation λ d'un polynôme de degré 12. La courbe…
5. Pourquoi ne faut-il pas choisir le degré du polynôme qui minimise l'erreur de test ?
6. Quel remède ne réduit PAS le surapprentissage ?
7. Dans la décomposition biais-variance, quelle partie de l'erreur aucun modèle ne peut réduire ?

Le TP guidé « Trouver la bonne complexité » reprend toute la démarche sur un vrai jeu de données : constater le surapprentissage, tracer la courbe de complexité, choisir le réglage par validation croisée, puis l’évaluer une seule fois sur le test. À la fin, vous récupérez le notebook Jupyter de tout ce que vous avez fait.

🔬Les démos et TP guidés

Choisissez « Trouver la bonne complexité ».

→