Pipeline : du tableau à la prédiction

Dans la leçon 4.3, nous avons mis des mesures à l’échelle, et dans la leçon 4.5, nous avons cherché des fuites. Aujourd’hui, nous assemblons tout cela en une seule machine. Un pipeline est une liste d’étapes qui transforme un tableau brut en prédiction : mise à l’échelle, encodage, modèle. Dans scikit-learn, c’est un seul objet : on l’ajuste comme un modèle et on l’interroge comme un modèle. La question clé : dans quel ordre ?

À vous

• Commencez par le scaler de l’entraînement. Passez au scaler de toutes les données. Combien de prédictions changent, et pourquoi ?
• Choisissez le scaler ajusté sur le test et changez la façon dont arrivent les manchots. Quand le modèle cesse-t-il de fonctionner ?
• Assemblez le pipeline à partir des blocs. Lequel des trois pièges est le plus tentant ?

Une fois vérifié dans le lab, mettons des mots sur ce que vous voyez.

L’idée en mots simples

Un scaler n’est pas une préparation des données « avant le modèle ». C’est la première partie du modèle. Pour chaque colonne, il garde deux nombres : une moyenne et un écart-type. D’abord il les apprend, puis il convertit avec eux. Comme toute partie d’un modèle, il n’apprend que sur l’entraînement. Le test se convertit avec les mêmes nombres, exactement comme plus tard chaque nouveau manchot.

Un scaler ajusté sur le test lui-même enfreint cette règle : le test reçoit sa propre moyenne et sa propre dispersion. Quand tout le test arrive à la fois et ressemble à l’entraînement, le résultat a l’air bon : 98,0 %. Quand arrivent des lots d’une seule île, ce n’est plus que 82,4 %. Dans les données, Torgersen n’a que des manchots Adelie. Une fois leur propre moyenne retirée, le modèle en reconnaît 6 sur 13. Quand les manchots arrivent un par un, l’exactitude tombe à 44,1 %. Un seul manchot n’a pas de dispersion, donc après la conversion il vaut zéro dans chaque colonne. Le modèle les appelle tous « Adelie », exactement comme « toujours Adelie ».

Un pipeline colle les étapes en un seul objet, ici le scaler et le kNN. Ajusté sur l’entraînement, il apprend d’un coup les moyennes, les écarts-types et le modèle lui-même, et pour prédire il ne fait que convertir et interroger. La validation croisée avec un pipeline réajuste le scaler dans chaque fold, donc aucun fold de test ne touche l’apprentissage. À quoi cela ressemble dans scikit-learn, la couche « En code » en bas de la leçon le montre.

Jak to policzono

• Manchots : Palmer Penguins (Gorman, Williams et Fraser, 2014 ; licence CC0), 342 manchots avec quatre mesures. Découpage stratifié : 240 pour apprendre, 102 pour le test. Les points du lab sont 20 découpages avec d’autres graines.
• Modèle : kNN avec k = 5 sur les mesures standardisées (moyenne 0, écart-type 1). Le scaler est ajusté sur l’entraînement, sur les 342 manchots ou sur le test lui-même : tout à la fois, séparément pour chaque île ou séparément pour chaque manchot.

Pourquoi ça marche

En usage réel, un modèle reçoit des manchots qui n’étaient pas dans les données, souvent un par un. Il n’y a alors ni « toutes les données » ni « tout le test ». Il y a de nouveaux manchots et les nombres retenus pendant l’apprentissage. Une évaluation est honnête quand le test suit exactement le même chemin. Un pipeline l’impose : il n’apprend que sur l’entraînement, et tout le reste est seulement converti et évalué.

Un scaler ajusté sur toutes les données enfreint aussi cette règle, mais en silence. Sur les manchots, cela ne change presque rien : la longueur moyenne de la nageoire sur 342 et sur 240 manchots diffère de 0,2 mm, et dans chacun des 20 découpages du lab les prédictions sont les mêmes. Le résultat apparent et le résultat honnête diffèrent ici de 0. Dans le code ci-dessous, scikit-learn donne sur 50 découpages les mêmes prédictions dans 50 cas sur 50. Mais un scaler ne voit pas les étiquettes. Une étape qui les voit peut fuir beaucoup au même endroit : dans la leçon 4.5, choisir les variables sur toutes les données a fait un « modèle » à partir de bruit pur. Un pipeline protège des deux, donc vous n’avez pas à vérifier à chaque fois si, cette fois, la fuite est petite.

Une erreur fréquente

Vrai ou faux : « On peut aussi ajuster le scaler sur le test lui-même ; après tout, le test et l’entraînement ont alors la même échelle ». Faux. Le test reçoit sa propre moyenne et sa propre dispersion, alors que le modèle a appris avec les nombres de l’entraînement. Sur les manchots, cela paraît inoffensif seulement quand tout le test arrive à la fois : 98,0 %. Par lots d’une île, c’est 82,4 %, un par un 44,1 %. Sur les 20 découpages du lab, en moyenne 76,9 % et 42,9 %, alors que le pipeline donne 99,2 %. Dans le code ci-dessous : à la fois 0,971, par île 0,786, un par un 0,437, autant que « toujours Adelie ».

La règle est simple : le scaler apprend sur l’entraînement, et le test et les nouvelles données sont seulement convertis avec les mêmes nombres. Un pipeline le fait pour vous.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

df = pd.read_csv("data/raw/penguins.csv")
cols = ["bill_length_mm", "bill_depth_mm", "flipper_length_mm", "body_mass_g"]
d = df.dropna(subset=cols)
X, y = d[cols], d["species"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, stratify=y, random_state=1)
pipe = make_pipeline(StandardScaler(), KNeighborsClassifier(5))  # le scaler fait partie du modèle
print(f"train {len(y_tr)}, test {len(y_te)}; CV on the training part: {cross_val_score(pipe, X_tr, y_tr, cv=5).mean():.3f}")
pipe.fit(X_tr, y_tr)
print(f"test, scaler fitted on the training part: {pipe.score(X_te, y_te):.3f}")
knn = pipe[-1]  # le kNN ajusté, sans son scaler
batch = knn.score(StandardScaler().fit_transform(X_te), y_te)  # fit_transform sur le test
right = [knn.predict(StandardScaler().fit_transform(part)) == y_te[part.index] for _, part in X_te.groupby(d["island"])]
one = [knn.predict(StandardScaler().fit_transform(X_te.loc[[i]]))[0] == y_te[i] for i in X_te.index]
print(f"fit_transform on the test: all at once {batch:.3f}, by island {np.concatenate(right).mean():.3f}, one at a time {np.mean(one):.3f}")
print(f"always Adelie: {(y_te == 'Adelie').mean():.3f}")
same = equal = 0
for s in range(50):
    a, b, ya, yb = train_test_split(X, y, test_size=0.3, stratify=y, random_state=s)
    honest = make_pipeline(StandardScaler(), KNeighborsClassifier(5)).fit(a, ya).predict(b)
    scaler = StandardScaler().fit(X)  # scaler.fit(X) : tous les manchots, avant le découpage
    leaky = KNeighborsClassifier(5).fit(scaler.transform(a), ya).predict(scaler.transform(b))
    same += (honest == leaky).all()
    equal += (leaky == yb).sum() == (honest == yb).sum()
print(f"scaler.fit(X) before the split, 50 splits: the same predictions in {same} of 50, the same test accuracy in {equal} of 50")

train 239, test 103; CV on the training part: 0.983
test, scaler fitted on the training part: 0.961
fit_transform on the test: all at once 0.971, by island 0.786, one at a time 0.437
always Adelie: 0.437
scaler.fit(X) before the split, 50 splits: the same predictions in 50 of 50, the same test accuracy in 50 of 50