Aller au contenu principal

Généraliser

Ce que ce chapitre apporte

  • Dire pourquoi l'erreur d'apprentissage n'est pas l'objectif.
  • Séparer un jeu en apprentissage, validation et test, et respecter la règle qui va avec.
  • Reconnaître le sous-apprentissage et le sur-apprentissage sur une figure et sur des chiffres.
  • Décomposer une erreur en biais, variance et bruit.
  • Choisir un réglage par validation croisée, sans jamais toucher au jeu de test.
  • Expliquer ce que fait une pénalité, et pourquoi elle ne réduit pas le nombre de paramètres.
  • Lire une courbe d'apprentissage et dire si plus de données servirait à quelque chose.
Les deux chapitres précédents ont appris à minimiser une erreur, par une formule puis en descendant une pente. Ce chapitre montre que cette erreur n'est pas celle qui compte. Un modèle qui reproduit parfaitement les données dont il dispose peut être sans valeur, et il existe une façon très simple de s'en apercevoir : lui montrer des données qu'il n'a jamais vues. Tout ce qui suit découle de ce geste, y compris les questions les plus délicates du domaine.

Ce que l'on cherche vraiment

Minimiser l'erreur d'apprentissage n'est pas l'objectif
C'est même une façon très fiable de produire un modèle inutile. Il existe toujours un modèle assez souple pour passer exactement par tous les points dont il dispose, et son erreur d'apprentissage vaut alors zéro.
Un tel modèle n'a rien appris. Il a retenu, ce qui n'est pas la même chose : il reproduit les réponses qu'on lui a montrées et n'a aucune raison d'en produire de correctes ailleurs.
L'objectif est de bien se comporter sur des données qui n'existaient pas au moment de l'apprentissage. C'est cela, généraliser, et c'est la seule chose qui compte.
La séparation, et sa règle

Les données se répartissent en trois jeux :

  • Apprentissage : les exemples sur lesquels les coefficients sont ajustés.
  • Validation : ceux sur lesquels les réglages sont choisis, degré, pénalité, architecture.
  • Test : ceux sur lesquels la performance finale est mesurée, et rien d'autre.

La règle tient en une phrase : le jeu de test ne sert qu'une fois, à la fin, et aucune décision ne remonte de lui.

Pourquoi trois jeux et non deux
Deux jeux suffisent pour mesurer. Trois deviennent nécessaires dès qu'on choisit.
Comparer quinze réglages sur le jeu de test et retenir le meilleur revient à optimiser sur ce jeu. Le chiffre obtenu n'est alors plus une estimation, c'est le minimum d'une liste, et il est systématiquement trop optimiste : il a été choisi pour être bas.
Le jeu de validation absorbe ce choix, et le jeu de test reste vierge pour donner un chiffre honnête à la fin.
C'est la même fuite d'information que celle du chapitre 3, sous une autre forme. Elle est ici plus discrète, parce qu'aucune colonne n'est copiée : c'est la décision qui transporte l'information.

Le sur-apprentissage, avec un curseur

Douze relevés, et vingt autres mis de côté qui n'entrent jamais dans l'ajustement. Le curseur du degré est le sujet de la section.

024680246charge du processeurlatence (ms)
erreur apprentissage 1,9054erreur test 1,9436plus grand coefficient 3,5647

Les deux erreurs sont élevées et proches : le modèle est trop rigide pour suivre la forme des données. C'est du sous-apprentissage.

Points pleins pour l'apprentissage, points creux pour le test. Monter le degré de 1 à 11 fait descendre l'erreur d'apprentissage sans jamais la faire remonter, jusqu'à zéro au degré 11 où la courbe passe exactement par les douze points. L'erreur de test, elle, passe par un creux au degré 3 puis se compte en dizaines, en centaines, puis en millions.
Trois positions du curseur, trois situations

Degré 1. Erreur d'apprentissage 1,91, erreur de test 1,94. Les deux sont élevées et proches. Le modèle est trop rigide pour suivre la forme des données : il se trompe partout, et il se trompe autant sur ce qu'il a vu que sur ce qu'il n'a pas vu. C'est du sous-apprentissage.

Degré 3. Erreur d'apprentissage 0,25, erreur de test 0,26. Les deux sont basses et proches. Le modèle a capté la forme sans apprendre le bruit.

Degré 10. Erreur d'apprentissage 0,02, erreur de test 720. La courbe passe presque exactement par les douze points d'apprentissage, en ondulant violemment entre eux. C'est du sur-apprentissage, et l'écart entre les deux erreurs en est la signature.

Le diagnostic tient dans deux nombres
Les deux erreurs élevées et proches : le modèle est trop simple. Ajouter de la souplesse, ou de meilleurs attributs.
Les deux erreurs basses et proches : c'est le bon régime.
L'erreur d'apprentissage basse et celle de test élevée : le modèle a appris le bruit. Le simplifier, le pénaliser, ou lui donner plus de données.
L'erreur d'apprentissage élevée et celle de test basse : cela n'arrive pas, sauf erreur de programmation. C'est le signe qu'il faut relire le code, en général parce que les deux jeux ont été échangés.

La courbe en U

main.py
Sortie
>_ Prêt à exécuter…
Les deux courbes ne font pas la même chose
L'erreur d'apprentissage ne remonte jamais. Elle passe de 1,91 à exactement 0,0000 au degré 11, où la courbe interpole les douze points. C'est mécanique : plus de souplesse ne peut pas faire moins bien sur les points qu'on cherche à approcher.
L'erreur de test passe par un creux à 0,26 au degré 3, puis remonte à 33, 837, et enfin plus de deux millions au degré 11.
Les données ont été fabriquées par un polynôme de degré 3 auquel s'ajoute un bruit d'écart-type 0,55. Le plancher est donc 0,552=0,300{,}55^2 = 0{,}30, et le degré 3 l'atteint. Descendre au-dessous sur les données d'apprentissage ne veut plus rien dire : c'est le bruit qu'on ajuste.
Noter enfin qu'au degré 11 les chiffres eux-mêmes cessent d'être fiables. Les puissances de xx deviennent si semblables que le système est au bord de l'insoluble, et le modèle n'est plus seulement inutile : il n'est plus calculable de façon reproductible.

Biais, variance et bruit

La décomposition

En moyenne sur tous les jeux d'apprentissage possibles, l'erreur d'un modèle en un point se sépare en trois termes :

erreur=biais2⏟il vise aˋ coˆteˊ+variance⏟il change tout le temps+bruit⏟irreˊductible\text{erreur} = \underbrace{\text{biais}^2}_{\text{il vise à côté}} + \underbrace{\text{variance}}_{\text{il change tout le temps}} + \underbrace{\text{bruit}}_{\text{irréductible}}

Le biais mesure l'écart entre la prévision moyenne du modèle et la vérité. Le variance mesure de combien la prévision change quand on refait l'apprentissage sur d'autres données.

main.py
Sortie
>_ Prêt à exécuter…
Ce que montrent les trois panneaux

Degré 1, biais² 1,93 et variance 0,44. Les vingt-cinq droites sont presque superposées : le modèle est stable. Elles sont toutes également fausses, et leur moyenne manque nettement la vérité. C'est un biais élevé.

Degré 3, biais² 0,007 et variance 0,26. Les courbes serrent la vérité, et leur moyenne s'y confond. Les deux termes sont bas en même temps.

Degré 7, biais² 40,7 et variance 1 389. Les courbes partent dans toutes les directions. Chacune est ajustée sur douze points seulement, et douze points différents donnent un modèle entièrement différent. C'est une variance énorme.

Le tableau vérifie l'identité : la somme des trois termes redonne exactement l'erreur mesurée, ligne par ligne. Ce n'est pas une affirmation du cours, c'est un contrôle que le bloc effectue.

Le compromis, et ce qu'on peut en faire
Un modèle rigide a un biais élevé et une variance faible. Un modèle souple a l'inverse. On ne peut pas annuler les deux à la fois en jouant sur la seule souplesse, et c'est pour cela que la courbe de test a une forme de U.
Le bruit, lui, ne se réduit pas du tout. Il ne dépend que du problème, et il fixe le plancher que le chapitre a mesuré à 0,30.
Il existe pourtant deux façons de sortir du compromis plutôt que de le subir, et les deux sections suivantes leur sont consacrées : pénaliser un modèle souple pour lui retirer de la variance sans lui rendre son biais, et lui donner plus de données, ce qui fait tomber la variance sans rien coûter au biais.

La pénalité

Régularisation

Plutôt que de minimiser la seule erreur, on minimise

E(θ)+λ∑j≥1θj2E(\theta) + \lambda \sum_{j \geq 1} \theta_j^2

Le second terme pénalise les grands coefficients. Le réglage λ\lambda dose la sévérité : à λ=0\lambda = 0 on retrouve l'ajustement ordinaire, et quand λ\lambda grandit les coefficients sont écrasés vers zéro.

La constante θ0\theta_0 n'est pas pénalisée : la rétrécir tirerait toutes les prévisions vers zéro, ce qui n'a aucun sens.

Reprendre la figure ci-dessous au degré 10, puis pousser le second curseur.

024680246charge du processeurlatence (ms)
erreur apprentissage 0,0198erreur test 720,7plus grand coefficient 4 116

L'écart entre les deux erreurs est le sur-apprentissage : la courbe a appris le bruit des points d'apprentissage, qui ne se retrouve dans aucune donnée nouvelle.

Le même degré 10 qui ondulait, avec une pénalité. Sans elle, le plus grand coefficient vaut 4 116 et l'erreur de test 720. À une pénalité de 0,1 le plus grand coefficient tombe à 2,3 et l'erreur de test à 0,30, soit le résultat du degré 3. Les onze coefficients sont toujours là : ils ont simplement cessé d'être énormes.
Une pénalité ne réduit pas le nombre de paramètres
C'est le point le plus contre-intuitif du chapitre, et il est facile à vérifier sur la figure.
Le modèle pénalisé a exactement les onze mêmes coefficients que le modèle qui ondulait. Aucun n'a été retiré. Ce qui a changé est leur amplitude : le plus grand passe de 4 116 à 2,3.
Une courbe ondule parce que ses coefficients sont grands et de signes opposés, chacun compensant l'autre pour passer par un point de plus. Leur interdire d'être grands interdit l'ondulation, sans rien interdire d'autre.
Ce n'est donc pas le nombre de paramètres qui nuit à la généralisation, c'est la liberté qu'on leur laisse. Un modèle à des millions de paramètres, correctement contraint, peut très bien généraliser, et c'est ce qui rend possible tout ce qui se fait aujourd'hui.

La validation croisée

Validation croisée en k paquets

Découper le jeu d'apprentissage en kk paquets. Pour chaque paquet, apprendre sur les k−1k-1 autres et mesurer sur celui-là. Le score est la moyenne des kk mesures.

Chaque exemple sert donc une fois à mesurer et k−1k-1 fois à apprendre, ce qui donne une estimation utilisable même quand les données sont peu nombreuses.

main.py
Sortie
>_ Prêt à exécuter…
Ce que le tableau démontre

La validation croisée retient le degré 3 avec une pénalité de 0,1, sur la seule foi des douze points d'apprentissage. Mesuré ensuite sur les vingt points de test jamais utilisés, ce réglage donne 0,2397.

Un choix fait en trichant, c'est-à-dire en essayant les trente réglages directement sur le jeu de test et en gardant le meilleur, aurait retenu exactement le même. La validation croisée a donc trouvé la bonne réponse sans jamais regarder ce qu'elle n'avait pas le droit de regarder.

Deux détails valent d'être notés.

Le score de validation (0,527) est plus élevé que l'erreur de test (0,240). Ce n'est pas une contradiction : chaque modèle de la validation croisée n'a été ajusté que sur neuf points au lieu de douze. La validation croisée est légèrement pessimiste par construction, et c'est le bon sens dans lequel se tromper.

Le degré 10 sans pénalité est déclaré impossible. Avec neuf points par paquet et onze coefficients à trouver, il n'y a rien à résoudre. La procédure élimine d'elle-même les réglages que les données ne peuvent pas soutenir.

Combien de paquets
Cinq ou dix conviennent presque toujours. Peu de paquets donne des modèles ajustés sur peu de données, donc une estimation pessimiste ; beaucoup de paquets coûte cher et donne des mesures très corrélées entre elles.
Deux précautions changent les résultats plus souvent qu'on ne croit. Si les classes sont déséquilibrées, découper en conservant leurs proportions dans chaque paquet. Si les données ont un ordre temporel, ne jamais mélanger : apprendre sur le passé et mesurer sur l'avenir, sans quoi le modèle lit des données postérieures à ce qu'il prédit.
Et si des lignes se rapportent au même individu, elles doivent rester dans le même paquet. Sinon le modèle reconnaît l'individu au lieu d'apprendre la règle, et le score obtenu n'a aucun rapport avec ce qu'il fera en service.

Plus de données

main.py
Sortie
>_ Prêt à exécuter…
Le sur-apprentissage n'est pas une propriété du modèle
C'est une relation entre la souplesse du modèle et la quantité de données.
Le degré 7 est catastrophique avec dix points : son erreur de test vaut 133 141. Avec trente points elle tombe à 0,62, avec cent vingt à 0,32. Le même modèle, sans le moindre changement, devient parfaitement convenable.
Dire « ce modèle sur-apprend » n'a donc pas de sens tout seul. Il faut dire « ce modèle sur-apprend avec ces données-là », et cela ouvre une issue que le compromis biais-variance semblait interdire : au lieu de simplifier le modèle, en collecter davantage.
Lire une courbe d'apprentissage, et savoir quoi faire
On y porte les deux erreurs en fonction du nombre d'exemples. Trois formes, trois décisions.
Les deux courbes se sont rejointes et sont hautes. Le modèle est trop simple, et plus de données n'y changera rien. Il faut un modèle plus souple ou de meilleurs attributs.
Les deux courbes se sont rejointes et sont basses, sur le plancher. Le travail est terminé : il ne reste que du bruit, et rien ne peut faire mieux.
Un large écart subsiste et l'erreur de test descend encore. Plus de données va servir, et c'est souvent l'action la plus rentable.
Cette figure se trace avant d'engager une collecte, pas après. Elle est le seul moyen honnête de savoir si les données manquantes valent leur coût.

Exercices type

Un modèle a une erreur d'apprentissage nulle. Est-ce une bonne nouvelle ?

Non, c'est presque toujours une mauvaise nouvelle.

Il existe toujours un modèle assez souple pour passer exactement par tous les points dont il dispose. Le chapitre en donne l'exemple : le polynôme de degré 11 traverse les douze points d'apprentissage, erreur 0,0000, et son erreur de test dépasse deux millions.

Un tel modèle n'a rien appris, il a retenu. Il reproduit les réponses qu'on lui a montrées et n'a aucune raison d'en produire de correctes ailleurs.

La seule conclusion à tirer d'une erreur d'apprentissage nulle est qu'il faut aller regarder l'erreur sur des données que le modèle n'a pas vues.

Pourquoi trois jeux de données et non deux ?

Parce que mesurer et choisir sont deux opérations différentes.

Deux jeux suffisent pour mesurer une performance. Mais dès qu'on essaie plusieurs réglages et qu'on garde le meilleur sur le jeu de test, le chiffre obtenu n'est plus une estimation : c'est le minimum d'une liste, choisi pour être bas.

Le jeu de validation absorbe ce choix. Le jeu de test reste vierge et donne un chiffre honnête à la fin.

C'est la même fuite d'information que celle du chapitre 3, en plus discret : aucune colonne n'est copiée, c'est la décision elle-même qui transporte l'information du test vers le modèle.

Les deux erreurs sont élevées et proches. Que faut-il faire ?

Rendre le modèle plus souple, ou lui donner de meilleurs attributs.

Deux erreurs élevées et proches signalent du sous-apprentissage : le modèle est trop rigide pour suivre la forme des données, il se trompe partout, et il se trompe autant sur ce qu'il a vu que sur ce qu'il n'a pas vu.

Ce qu'il ne faut surtout pas faire, c'est collecter plus de données. La courbe d'apprentissage le montre : quand les deux courbes se sont déjà rejointes à un niveau élevé, ajouter des exemples ne change rien du tout.

Le diagnostic inverse, erreur d'apprentissage basse et erreur de test élevée, appelle exactement les remèdes opposés.

Une pénalité réduit-elle le nombre de paramètres du modèle ?

Non, aucun paramètre n'est retiré.

Le modèle pénalisé du chapitre a exactement les onze mêmes coefficients que celui qui ondulait. Ce qui change est leur amplitude : le plus grand passe de 4 116 à 2,3.

Une courbe ondule parce que ses coefficients sont grands et de signes opposés, chacun compensant l'autre pour passer par un point de plus. Leur interdire d'être grands interdit l'ondulation, sans rien interdire d'autre.

La conséquence dépasse largement ce chapitre : ce n'est pas le nombre de paramètres qui nuit à la généralisation, c'est la liberté qu'on leur laisse. Un modèle à des millions de paramètres, correctement contraint, peut très bien généraliser.

Le score de validation croisée vaut 0,53 et l'erreur de test 0,24. Le modèle est-il mal évalué ?

Non, l'écart va dans le bon sens et s'explique.

Chaque modèle de la validation croisée en quatre paquets n'a été ajusté que sur neuf points au lieu de douze. Moins de données donne un modèle moins bon, donc un score plus élevé.

La validation croisée est donc légèrement pessimiste par construction, et c'est le bon sens dans lequel se tromper : elle sous-promet.

Ce qui devrait inquiéter est l'écart inverse, un score de validation nettement meilleur que l'erreur de test. Il signale en général une fuite d'information : préparation faite avant le découpage, lignes du même individu réparties entre les paquets, ou données temporelles mélangées.

Faut-il collecter plus de données ? Comment le savoir avant de payer pour elles ?

En traçant la courbe d'apprentissage avec les données déjà disponibles.

On y porte les deux erreurs en fonction du nombre d'exemples, en apprenant sur des sous-ensembles de taille croissante.

Si les deux courbes se sont déjà rejointes, plus de données ne servira à rien : soit elles sont hautes et il faut un meilleur modèle, soit elles sont sur le plancher de bruit et le travail est terminé.

Si un large écart subsiste et que l'erreur de test descend encore, plus de données va servir, et la pente indique de combien.

C'est la seule façon honnête de répondre avant d'engager la dépense, et elle ne coûte que du calcul.

Vérification rapideon peut se reprendre

1.Un modèle a une erreur d'apprentissage de zéro. Que peut-on en conclure ?

2.À quoi sert le jeu de validation, distinct du jeu de test ?

3.Les deux erreurs sont élevées et proches l'une de l'autre. C'est…

4.Que fait une pénalité sur les coefficients ?

5.Un modèle de degré 7 a une erreur de test de 133 141 avec dix points et de 0,32 avec cent vingt. Cela montre que…

6.Le score de validation croisée est plus élevé que l'erreur de test. Faut-il s'en inquiéter ?

La méthode

  1. Séparer les données avant tout traitement, en apprentissage, validation et test.
  2. N'ouvrir le jeu de test qu'une fois, à la fin, et ne laisser aucune décision en remonter.
  3. Comparer les deux erreurs systématiquement, jamais l'erreur d'apprentissage seule.
  4. Diagnostiquer : les deux hautes et proches, trop simple ; écartées, trop souple.
  5. Choisir les réglages par validation croisée, sur le seul jeu d'apprentissage.
  6. Grouper les paquets par individu, respecter l'ordre du temps, conserver les proportions de classes.
  7. Pénaliser un modèle souple plutôt que de le simplifier, quand c'est possible.
  8. Tracer la courbe d'apprentissage avant d'engager une collecte de données.

Synthèse

  • L'objectif n'est pas de minimiser l'erreur d'apprentissage mais de bien se comporter sur des données nouvelles.
  • Une erreur d'apprentissage nulle est un signal d'alarme, pas un résultat.
  • Trois jeux : apprentissage pour les coefficients, validation pour les réglages, test une seule fois.
  • L'erreur d'apprentissage ne remonte jamais quand la souplesse augmente ; l'erreur de test passe par un creux.
  • Le plancher est fixé par le bruit du problème, ici 0,552=0,300{,}55^2 = 0{,}30, et rien ne descend au-dessous.
  • L'erreur se décompose en biais², variance et bruit, et la somme redonne exactement l'erreur mesurée.
  • Un modèle rigide a du biais, un modèle souple a de la variance ; le U vient de là.
  • Une pénalité limite l'amplitude des coefficients sans en retirer aucun : ce n'est pas leur nombre qui nuit, c'est leur liberté.
  • La validation croisée choisit un réglage sans toucher au test, et se trompe du bon côté, en sous-promettant.
  • Le sur-apprentissage est une relation entre souplesse et quantité de données, pas une propriété du modèle.
  • La courbe d'apprentissage dit avant toute dépense si collecter plus de données servirait.

Mettre en pratique

La courbe en U, ce que coûte une validation croisée, et ce que la pénalité achète.

Tous les exercices sur généraliser