Pipeline: da tabela à previsão

Na lição 4.3 colocamos medidas em escala e na lição 4.5 procuramos vazamentos. Hoje juntamos tudo numa só máquina. Um pipeline é uma lista de passos que transforma uma tabela bruta numa previsão: escala, codificação, modelo. No scikit-learn ele é um só objeto: você o ajusta como um modelo e pergunta a ele como a um modelo. A pergunta-chave é: em que ordem?

Experimente

• Comece com o scaler do treino. Troque para o scaler de todos os dados. Quantas previsões mudam, e por quê?
• Escolha o scaler ajustado no teste e mude a forma como os pinguins chegam. Quando o modelo para de funcionar?
• Monte o pipeline com os blocos. Qual das três armadilhas tenta mais?

Depois de conferir no lab, vamos dar nome ao que você vê.

A ideia em palavras simples

Um scaler não é preparação de dados “antes do modelo”. Ele é a primeira parte do modelo. Para cada coluna, guarda dois números: uma média e um desvio padrão. Primeiro aprende esses números, depois converte com eles. Como toda parte de um modelo, aprende só no treino. O teste é convertido com os mesmos números, assim como depois cada pinguim novo.

Um scaler ajustado no próprio teste quebra essa regra: o teste ganha a própria média e a própria dispersão. Quando o teste inteiro chega de uma vez e se parece com o treino, o resultado parece bom: 98,0%. Quando chegam lotes de uma só ilha, já são só 82,4%. Nos dados, Torgersen só tem pinguins Adelie. Tirada a própria média, o modelo reconhece 6 de 13. Quando os pinguins chegam um de cada vez, a acurácia cai para 44,1%. Um pinguim sozinho não tem dispersão, então depois da conversão ele vira zero em todas as colunas. O modelo chama todos de “Adelie”, exatamente o que faz “sempre Adelie”.

Um pipeline junta os passos num só objeto, aqui o scaler e o kNN. Ajustado no treino, ele aprende de uma vez as médias, os desvios e o próprio modelo, e na previsão só converte e pergunta. A validação cruzada com um pipeline ajusta o scaler de novo em cada fold, então nenhum fold de teste toca o aprendizado. Como isso fica no scikit-learn, a camada “No código” no fim da lição mostra.

Jak to policzono

• Pinguins: Palmer Penguins (Gorman, Williams e Fraser, 2014; licença CC0), 342 pinguins com quatro medidas. Divisão estratificada: 240 para aprender, 102 para o teste. Os pontos do lab são 20 divisões com outras sementes.
• Modelo: kNN com k = 5 nas medidas padronizadas (média 0, desvio 1). O scaler é ajustado no treino, nos 342 pinguins ou no próprio teste: todo de uma vez, separadamente em cada ilha ou separadamente em cada pinguim.

Por que funciona

No uso real, um modelo recebe pinguins que não estavam nos dados, muitas vezes um de cada vez. Aí não existe “todos os dados” nem “o teste inteiro”. Existem pinguins novos e os números guardados durante o aprendizado. Uma avaliação é honesta quando o teste segue exatamente o mesmo caminho. Um pipeline obriga a isso: ele aprende só no treino, e todo o resto só é convertido e avaliado.

Um scaler ajustado em todos os dados também quebra essa regra, só que em silêncio. Nos pinguins isso quase não muda nada: o comprimento médio da nadadeira de 342 e de 240 pinguins difere em 0,2 mm, e em cada uma das 20 divisões do lab as previsões são as mesmas. O resultado aparente e o honesto diferem aqui em 0. No código abaixo, o scikit-learn dá em 50 divisões as mesmas previsões em 50 de 50. Mas um scaler não vê os rótulos. Um passo que vê pode vazar muito no mesmo lugar: na lição 4.5, escolher atributos em todos os dados fez um “modelo” a partir de ruído puro. Um pipeline protege contra as duas coisas, então você não precisa verificar toda vez se desta vez o vazamento é pequeno.

Um erro comum

Verdadeiro ou falso: “Também dá para ajustar o scaler no próprio teste; afinal, o teste e o treino ficam com a mesma escala”. Falso. O teste ganha a própria média e a própria dispersão, enquanto o modelo aprendeu com os números do treino. Nos pinguins isso só parece inofensivo quando o teste inteiro chega de uma vez: 98,0%. Em lotes de uma ilha são 82,4%, um de cada vez 44,1%. Nas 20 divisões do lab, em média 76,9% e 42,9%, enquanto o pipeline dá 99,2%. No código abaixo: de uma vez 0,971, por ilha 0,786, um de cada vez 0,437, o mesmo que “sempre Adelie”.

A regra é simples: o scaler aprende no treino, e o teste e os dados novos só são convertidos com os mesmos números. Um pipeline faz isso por você.

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))  # o scaler é parte do modelo
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]  # o kNN ajustado, sem o seu scaler
batch = knn.score(StandardScaler().fit_transform(X_te), y_te)  # fit_transform no teste
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): todos os pinguins, antes da divisão
    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