Courbes d’apprentissage : données ou meilleur modèle ?

Dans la leçon 3.1, le modèle était trop simple ou trop complexe, avec la même quantité de données. Aujourd’hui, vous changez la quantité de données. C’est une question de tous les jours en pratique : le modèle est moyen, faut-il collecter plus d’exemples ou changer de modèle ? La réponse vient d’une courbe d’apprentissage : le score en entraînement et en validation, tracé pour un ensemble d’entraînement de plus en plus grand.

À vous de jouer

• Avec le modèle détaillé, faites glisser le curseur de 50 à 1438 images. Quelle courbe change le plus : entraînement ou validation ?
• Passez au modèle des chiffres floutés. Où ses courbes se rejoignent-elles, et à quelle hauteur ?
• Comparez le modèle détaillé avec 100 images et le modèle flouté avec 1438. Lequel gagne ?

Une fois vérifié dans le lab, nommons ce que vous voyez.

L’idée en quelques mots

Une courbe d’apprentissage, ce sont deux lignes : l’exactitude sur les données d’entraînement et en validation, en fonction du nombre d’exemples d’entraînement. Avec quelques dizaines d’images, le modèle mémorise chacune : l’entraînement a 100 % et la validation 82,3 %. Plus il y a de données, plus il est difficile de tout mémoriser, donc l’entraînement baisse (à 98,0 %) et la validation monte (à 95,8 %). L’écart entre les deux passe de 17,7 à 2,2 points.

La forme de ces lignes vous donne la décision :

• Grand écart, validation qui monte encore (variance élevée) : le modèle connaît ses données d’entraînement bien mieux que les nouvelles. Plus de données aideront, la régularisation aussi.
• Petit écart, les deux lignes basses (biais élevé) : le modèle est trop simple. Les courbes se sont rejointes et plus de données n’aideront presque pas. Un modèle plus riche ou de meilleures variables aideront.

Le modèle des chiffres floutés voit chaque chiffre comme une image de 4 × 4, soit 16 pixels au lieu de 64. Avec 1438 images, il a 86,9 % en entraînement et 85,0 % en validation, un écart de seulement 1,9 point. La validation ne dépasse généralement pas l’entraînement, qui n’a que 86,9 %. Le modèle détaillé atteint déjà 87,6 % avec seulement 100 images.

Jak to policzono

• Chiffres : Optical Recognition of Handwritten Digits, UCI, licence CC BY 4.0. 1797 images de 8 × 8 pixels, 10 chiffres.
• Un découpage 80/20 stratifié, le même que dans le widget de l’Atlas : 1438 images pour apprendre, 359 pour valider. Pour chaque taille, la moyenne de 5 tirages des images utilisées pour apprendre.
• Modèle : régression logistique (softmax) avec une pénalité de 0,001 sur les grands poids. Le modèle flouté voit les moyennes de blocs de 2 × 2 pixels.

Pourquoi ça marche

En entraînement, le modèle voit les réponses, donc avec peu de données il peut les mémoriser. Chaque nouvel exemple rend la mémorisation plus difficile et rend plus facile de trouver une règle qui marche aussi hors de l’entraînement. C’est pourquoi les lignes se rapprochent : l’entraînement descend, la validation monte. Elles se rejoignent au niveau que ce modèle peut atteindre tout court.

Ce niveau dépend du modèle, pas des données. Une image floutée perd les détails qui distinguent, par exemple, un 3 d’un 8, et aucun nombre d’exemples ne les rend. Dans le code ci-dessous, la même expérience tourne sur 50 découpages différents : avec toutes les données, le modèle flouté a 86,4 % en entraînement et 85,1 % en validation, et le modèle détaillé 96,6 % en validation. Le modèle détaillé à partir de 100 images bat le modèle flouté à partir de 1437 images dans 49 découpages sur 50.

Erreur fréquente

Vrai ou faux : « plus de données aident toujours ». Faux. Plus de données aident quand le modèle est trop puissant pour la quantité de données : l’écart est alors grand et la validation continue de monter. Quand le modèle est trop simple, les courbes se rejoignent tôt et restent plates. Dans le lab, le modèle flouté a 83,6 % en validation avec 400 images, et 85,0 % avec un ensemble presque quatre fois plus grand. Le modèle détaillé a 95,8 % avec les mêmes données. Avant de payer pour collecter des données, tracez une courbe d’apprentissage : si le score d’entraînement est déjà bas, les données n’aideront pas.

Remarque : tracez les courbes en validation ou en validation croisée, pas sur le jeu de test. Le test reste réservé à l’évaluation finale.

import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X, y = load_digits(return_X_y=True)
X = X / 16  # 8 × 8 = 64 pixels de 0 à 1, comme dans le lab
X16 = X.reshape(-1, 4, 2, 4, 2).mean(axis=(2, 4)).reshape(len(X), -1)  # le même chiffre flouté en 4 × 4 = 16 pixels
def run(Z, n, seed):
    Xtr, Xva, ytr, yva = train_test_split(Z, y, test_size=0.2, stratify=y, random_state=seed)
    i = np.random.default_rng(seed).permutation(len(ytr))[:n]  # les n premières images d'entraînement après mélange
    m = LogisticRegression(C=1000 / n, max_iter=5000).fit(Xtr[i], ytr[i])  # C = 1000 / n est la pénalité 0,001 du lab
    return m.score(Xtr[i], ytr[i]), m.score(Xva, yva)
for name, Z in (("64 pixels", X), ("16 pixels", X16)):
    for n in (50, 100, 400, 800, 1437):
        tr, va = np.mean([run(Z, n, s) for s in range(50)], axis=0)  # moyenne de 50 découpages différents
        print(f"{name}, {n} images: training {tr:.1%}, validation {va:.1%}, gap {(tr - va) * 100:.1f} points")
wins = sum(run(X, 100, s)[1] > run(X16, 1437, s)[1] for s in range(50))
print(f"64 pixels from 100 images beat 16 pixels from 1437 images in {wins} of 50 splits")

64 pixels, 50 images: training 100.0%, validation 81.2%, gap 18.8 points
64 pixels, 100 images: training 100.0%, validation 89.5%, gap 10.5 points
64 pixels, 400 images: training 99.7%, validation 94.9%, gap 4.8 points
64 pixels, 800 images: training 99.0%, validation 96.0%, gap 2.9 points
64 pixels, 1437 images: training 98.2%, validation 96.6%, gap 1.6 points
16 pixels, 50 images: training 98.5%, validation 72.6%, gap 25.9 points
16 pixels, 100 images: training 94.1%, validation 79.8%, gap 14.4 points
16 pixels, 400 images: training 87.7%, validation 83.8%, gap 3.8 points
16 pixels, 800 images: training 86.9%, validation 84.6%, gap 2.3 points
16 pixels, 1437 images: training 86.4%, validation 85.1%, gap 1.3 points
64 pixels from 100 images beat 16 pixels from 1437 images in 49 of 50 splits