Données, variables, étiquettes et découpage

Si une professeure donne à sa classe exactement les questions de l’examen final et que tout le monde obtient la note maximale, qu’a mesuré l’examen ? La mémoire de ces questions, rien de plus. L’apprentissage automatique affronte ce problème à chaque fois, et sa solution est étonnamment simple : garder une partie des questions sous clé dans un tiroir.

À vous de jouer

• Réglez le curseur de la part de test sur une petite valeur, puis faites passer le curseur de la graine par plusieurs positions. Observez combien l’exactitude de test change alors que le modèle et les données restent les mêmes.
• Réglez maintenant la part de test sur une grande valeur et refaites l’expérience avec la graine. L’exactitude de test saute-t-elle plus ou moins qu’avant ?
• Gardez la graine fixe et déplacez la part de test d’un bout à l’autre. Remarquez comme le nombre de lignes d’entraînement diminue à mesure que le jeu de test grandit.
• Trouvez la graine qui donne la meilleure exactitude de test – puis demandez-vous si vous auriez le droit de publier ce chiffre.

L’idée en quelques mots

Voyons maintenant ce que vous venez de manipuler, en termes simples.

Presque tous les jeux de données de ce cours sont des tableaux. Chaque ligne est un exemple : une tumeur, une patiente, un passager, un vin. Chaque colonne est une variable (feature) : une propriété mesurée, comme un rayon, une tension artérielle, un âge ou un taux d’alcool. Une colonne particulière contient l’étiquette (label) – la réponse que le modèle doit prédire, par exemple « maligne » ou « a survécu ». Un modèle est une règle qui associe les variables d’une ligne à son étiquette.

Avant tout apprentissage, on mélange les lignes et on les répartit. La plus grande partie, le jeu d’entraînement, sert au modèle pour apprendre. La plus petite, le jeu de test, est mise sous clé et utilisée une seule fois, à la fin, pour estimer comment le modèle se débrouillera sur des lignes qu’il n’a jamais vues. Elle joue le rôle des questions dans le tiroir.

Imaginez une cheffe qui met au point une nouvelle soupe. Elle goûte sans arrêt pendant la cuisson – c’est l’entraînement. Mais pour savoir si les clients l’aimeront, elle la sert à quelques personnes qui ne l’ont jamais goûtée et n’ont aucune raison d’être polies. Leur verdict, c’est le score de test. Si elle ne demandait qu’à elle-même, elle trouverait toujours sa soupe parfaite.

Pourquoi ça marche

Le jeu de test n’est utile que parce que le modèle ne l’a jamais vu. Tant que les lignes d’entraînement et de test viennent de la même source et ont été réparties au hasard, les lignes de test se comportent comme de futurs cas, et l’exactitude de test est une estimation honnête de l’exactitude future.

Mais ce n’est qu’une estimation, et c’est là ce que les débutants entendent rarement. Le score de test dépend des lignes qui sont tombées par hasard dans le jeu de test. Mélangez les données avec une autre graine aléatoire (seed) et vous obtenez un autre jeu de test, et un autre score – avec exactement le même modèle et les mêmes données. Avec un petit jeu de test, le score peut sauter sensiblement, car une poignée de lignes inhabituelles pèse lourd dans le pourcentage. La statistique donne un ordre de grandeur de cette fluctuation. Pour une exactitude p mesurée sur n lignes de test, l’erreur type vaut environ

SE ≈ √(p · (1 − p) / n)

si bien que quatre fois plus de lignes de test ne divisent la fluctuation que par deux. C’est pourquoi un score de test unique n’est jamais toute la vérité.

Il y a aussi un compromis. Chaque ligne placée dans le jeu de test est une ligne dont le modèle ne peut pas apprendre. Un énorme jeu de test donne une note fiable à un modèle qui a appris sur trop peu de données ; un minuscule jeu de test donne une note peu fiable à un modèle bien entraîné. On place couramment entre un cinquième et un tiers des lignes dans le jeu de test, et les leçons suivantes montreront des façons plus astucieuses de sortir de ce dilemme.

Erreur fréquente

L’erreur la plus tentante consiste à essayer beaucoup de découpages et à garder celui qui donne le plus beau score de test. Le jeu de test a alors servi à prendre une décision, et le score annoncé est trop optimiste. Une version plus discrète de la même erreur s’appelle la fuite de données (data leakage) : des informations des lignes de test se glissent dans l’entraînement, par exemple quand on calcule des moyennes pour normaliser ou pour remplir des valeurs manquantes sur tout le tableau avant de le découper. La règle est stricte : découper d’abord, puis tout faire avec les seules lignes d’entraînement.

Avec un découpage propre en main, nous pouvons enfin construire un vrai modèle. Dans la prochaine leçon, nous ajustons le plus simple qui existe – une droite à travers un nuage de points.

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X = X.filter(like="mean ")  # les 10 variables « mean », comme dans le lab
accs = []
for seed in range(20):  # même modèle, 20 découpages différents
    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, stratify=y, random_state=seed)
    model = make_pipeline(StandardScaler(), LogisticRegression()).fit(Xtr, ytr)
    accs.append(model.score(Xte, yte))
n, p = len(yte), float(np.mean(accs))
print(f"test rows: {n}")
print(f"test accuracy: min {min(accs):.1%}, max {max(accs):.1%}")
print(f"standard error: {np.sqrt(p * (1 - p) / n):.1%} (n={n}), {np.sqrt(p * (1 - p) / (4 * n)):.1%} (n={4 * n})")

test rows: 171
test accuracy: min 90.6%, max 97.1%
standard error: 1.8% (n=171), 0.9% (n=684)