Lidsky řečeno
Sázkař si vsadí na včerejší zápas s výsledkem v ruce a ještě se diví, jak mu to jde. Jakmile musí sázet na zápasy, které se teprve odehrají, jeho geniální systém je pryč. Únik dat je totéž: do tréninku se dostane informace, kterou by model ve skutečném provozu v dané chvíli neměl. Skóre vypadá skvěle, jenže se měřil sázkař s novinami od zítřka.
Co je únik dat
Únik dat (data leakage) nastane, když se model při učení dozví něco, co by při skutečném použití nevěděl. Nejčastěji to má jednu ze tří podob:
| Podoba | Příklad |
|---|---|
| Příprava dat viděla i testovací řádky | průměr pro doplnění chybějících hodnot spočítaný z celé tabulky |
| Příznak obsahuje budoucnost nebo přímo odpověď | datum vrácení peněz při předpovědi, zda zákazník zboží vrátí |
| Tentýž objekt je v tréninku i v testu | duplicitní řádky, více snímků jednoho pacienta |
Nepříjemné na tom je, že nic nespadne. Program běží, čísla jsou krásná, všichni jsou spokojení. Pravda vyjde najevo až v provozu.
Skóre z ničeho
Nejsilnější ukázka vypadá takhle. Vyrobíme čistý šum: 60 řádků, 2000 náhodných sloupců a náhodné třídy 0 nebo 1. Není tu co se naučit, poctivý model musí skončit kolem 50 %, jako hod mincí.
Postup je rozumný na pohled: vybereme 20 sloupců, které s cílem nejvíc korelují, a na nich provedeme křížovou validaci. Korelace je číslo, které říká, jak moc dvě veličiny stoupají a klesají spolu. Rozdíl je jen v tom, kdy výběr uděláme. Celý pokus zopakujeme na deseti různých šumech, aby výsledek nezávisel na jedné náhodě.
import numpy as np
def vyber(X, y, k):
Xc = X - X.mean(axis=0)
yc = y - y.mean()
korelace = np.abs(Xc.T @ yc) / (np.linalg.norm(Xc, axis=0) * np.linalg.norm(yc))
return np.argsort(korelace)[-k:]
def presnost(X_tr, y_tr, X_va, y_va):
c0 = X_tr[y_tr == 0].mean(axis=0)
c1 = X_tr[y_tr == 1].mean(axis=0)
d0 = ((X_va - c0) ** 2).sum(axis=1)
d1 = ((X_va - c1) ** 2).sum(axis=1)
return np.mean((d1 < d0).astype(int) == y_va)
def pokus(seed):
rng = np.random.default_rng(seed)
X = rng.normal(size=(60, 2000))
y = rng.integers(0, 2, 60)
idx = np.arange(60)
spatne, spravne = [], []
# ŠPATNĚ: sloupce vybereme ze všech dat, až potom dělíme
sloupce = vyber(X, y, 20)
for v in np.array_split(idx, 5):
t = np.setdiff1d(idx, v)
spatne.append(presnost(X[t][:, sloupce], y[t], X[v][:, sloupce], y[v]))
# SPRÁVNĚ: výběr proběhne v každém foldu jen z trénovací části
s = vyber(X[t], y[t], 20)
spravne.append(presnost(X[t][:, s], y[t], X[v][:, s], y[v]))
return np.mean(spatne), np.mean(spravne)
vysledky = np.array([pokus(seed) for seed in range(10)])
print(f"výběr před dělením: {vysledky[:, 0].mean():.2f}")
print(f"výběr uvnitř foldu: {vysledky[:, 1].mean():.2f}")
výběr před dělením: 0.93 výběr uvnitř foldu: 0.49
První číslo vypadá jako model, který se dá prodat. Na datech, kde není žádný signál. Mezi 2000 náhodnými sloupci se totiž vždycky najde pár, které s cílem souhlasí čistě náhodou, a to včetně validačních řádků, protože i ty se na výběru podílely. Druhé číslo je pravda.
Pravidlo z toho plyne jediné a platí bez výjimky:
Všechno, co se učí z dat, se smí učit jen z trénovací části.To se netýká jen modelu, ale i průměrů, měřítek, výběru příznaků, doplňování chybějících hodnot nebo slovníku kategorií.
Únik, nebo v pořádku?
Roztřiď postupy.
fit se učí, transform používá
Skoro všechno ve scikit-learn má dvě metody:
fitse učí z dat a zapamatuje si, co zjistil.transformto naučené použije na jakákoli data.
Takže fit patří jen na trénink a transform na trénink i test. Tady je standardizace napsaná ručně. Odečítá průměr a dělí směrodatnou odchylkou, obojí zapamatované z tréninku. Tipni si výsledek: průměr tréninku [0, 10] je 5 a odchylka také 5.
import numpy as np
class Standardizer:
def fit(self, X, y=None):
self.prumer_ = X.mean(axis=0)
self.odchylka_ = X.std(axis=0)
return self
def transform(self, X):
return (X - self.prumer_) / self.odchylka_
trenink = np.array([[0.0], [10.0]])
test = np.array([[20.0]])
s = Standardizer().fit(trenink)
print(s.transform(test).item())
3.0
Testovací data se měří pravítkem z tréninku. V provozu ani jinak nejde: když přijde jeden nový zákazník, žádný „průměr testovacích dat“ neexistuje.
Standardizace bez dělení nulou
Napiš třídu Standardizer s metodami fit(X) a transform(X). fit uloží průměr do prumer_, směrodatnou odchylku do odchylka_ a vrátí self. Pokud je sloupec konstantní a jeho odchylka je nulová, ulož místo ní 1, aby se nedělilo nulou. transform používá uložené hodnoty.
import numpy as np
class Standardizer:
def fit(self, X):
return self
def transform(self, X):
return X
Kdo si půjčil test?
Kód má standardizovat data bez úniku. Jeden řádek to porušuje.
Slož postup bez úniku
Seřaď řádky tak, aby se data standardizovala správně. Jeden řádek je navíc.
Pipeline: řetěz, který to hlídá za tebe
V jedné smyčce se na to dá dávat pozor. V reálném projektu, kde je kroků pět a foldů deset, se chyba vloudí snadno. Pipeline spojí přípravu dat a model do jednoho objektu. Navenek se tváří jako obyčejný model s fit a predict. Uvnitř:
fit(X, y): krok1.fit + transform -> krok2.fit + transform -> model.fit
predict(X): krok1.transform -> krok2.transform -> model.predictŽádná magie v tom není. Celá věc se vejde do pár řádků. Spustíme ji na stejném šumu jako na začátku a předáme ji do křížové validace jako celek. Výběr příznaků se tak sám provede znovu v každém foldu. Můžeš si ji i krokovat.
import numpy as np
class MiniPipeline:
def __init__(self, kroky):
self.kroky = kroky
def fit(self, X, y):
for krok in self.kroky[:-1]:
X = krok.fit(X, y).transform(X)
self.kroky[-1].fit(X, y)
return self
def predict(self, X):
for krok in self.kroky[:-1]:
X = krok.transform(X)
return self.kroky[-1].predict(X)
class Standardizer:
def fit(self, X, y=None):
self.m_, self.s_ = X.mean(axis=0), X.std(axis=0)
return self
def transform(self, X):
return (X - self.m_) / self.s_
class VyberK:
def __init__(self, k):
self.k = k
def fit(self, X, y):
korelace = np.abs(X.T @ (y - y.mean()))
self.sloupce_ = np.argsort(korelace)[-self.k:]
return self
def transform(self, X):
return X[:, self.sloupce_]
class Centroidy:
def fit(self, X, y):
self.c0_, self.c1_ = X[y == 0].mean(axis=0), X[y == 1].mean(axis=0)
return self
def predict(self, X):
d0 = ((X - self.c0_) ** 2).sum(axis=1)
d1 = ((X - self.c1_) ** 2).sum(axis=1)
return (d1 < d0).astype(int)
skore = []
for seed in range(10):
rng = np.random.default_rng(seed)
X = rng.normal(size=(60, 2000))
y = rng.integers(0, 2, 60)
idx = np.arange(60)
for v in np.array_split(idx, 5):
t = np.setdiff1d(idx, v)
model = MiniPipeline([Standardizer(), VyberK(20), Centroidy()])
model.fit(X[t], y[t])
skore.append(np.mean(model.predict(X[v]) == y[v]))
print(f"přesnost s pipeline: {np.mean(skore):.2f}")
přesnost s pipeline: 0.48
Správně nudný výsledek kolem padesáti procent. Šum zůstal šumem.
Oprav podvádějící validaci
Funkce poctive_cv má spočítat křížovou validaci s výběrem příznaků. Teď podvádí: sloupce vybírá ze všech dat. Oprav ji tak, aby se vyber volal v každém foldu jen na trénovací části. Na čistém šumu musí vyjít přesnost blízko 0,5 a na datech se skutečným signálem vysoká.
import numpy as np
def vyber(X, y, k):
Xc = X - X.mean(axis=0)
yc = y - y.mean()
kor = np.abs(Xc.T @ yc) / (np.linalg.norm(Xc, axis=0) * np.linalg.norm(yc))
return np.argsort(kor)[-k:]
def presnost(X_tr, y_tr, X_va, y_va):
c0, c1 = X_tr[y_tr == 0].mean(axis=0), X_tr[y_tr == 1].mean(axis=0)
d0, d1 = ((X_va - c0) ** 2).sum(axis=1), ((X_va - c1) ** 2).sum(axis=1)
return np.mean((d1 < d0).astype(int) == y_va)
def poctive_cv(X, y, k, foldu=5):
idx = np.arange(len(y))
s = vyber(X, y, k)
skore = []
for v in np.array_split(idx, foldu):
t = np.setdiff1d(idx, v)
skore.append(presnost(X[t][:, s], y[t], X[v][:, s], y[v]))
return float(np.mean(skore))
Pipeline ve scikit-learn
make_pipeline vyrobí řetěz a kroky pojmenuje sám podle tříd, malými písmeny. Nejdřív stejný experiment se šumem. Přesnost špatného postupu by měla být vysoko, přesnost pipeline kolem poloviny.
import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import make_pipeline
cv = StratifiedKFold(5, shuffle=True, random_state=0)
spatne, spravne = [], []
for seed in range(5):
rng = np.random.default_rng(seed)
X = rng.normal(size=(60, 2000))
y = rng.integers(0, 2, 60)
X_vybrane = SelectKBest(f_classif, k=20).fit_transform(X, y)
spatne.append(cross_val_score(LogisticRegression(max_iter=1000), X_vybrane, y, cv=cv).mean())
pipe = make_pipeline(SelectKBest(f_classif, k=20), LogisticRegression(max_iter=1000))
spravne.append(cross_val_score(pipe, X, y, cv=cv).mean())
print(f"výběr před validací: {np.mean(spatne):.2f}")
print(f"výběr v pipeline: {np.mean(spravne):.2f}")
výběr před validací: 0.89 výběr v pipeline: 0.50
A teď skutečná data. Po natrénování se ke krokům dostaneš přes named_steps nebo indexem, řez pipe[:-1] je přípravná část bez modelu.
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
X, y = load_breast_cancer(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=0, stratify=y)
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000, random_state=0))
cv = StratifiedKFold(5, shuffle=True, random_state=0)
skore = cross_val_score(pipe, X_tr, y_tr, cv=cv)
print(f"křížová validace: {skore.mean():.3f}")
pipe.fit(X_tr, y_tr)
print(f"test: {pipe.score(X_te, y_te):.3f}")
print("kroky:", list(pipe.named_steps))
print("tvar po přípravě:", pipe[:-1].transform(X_te).shape)
print("počet vah modelu:", pipe[-1].coef_.shape[1])
křížová validace: 0.981 test: 0.958 kroky: ['standardscaler', 'logisticregression'] tvar po přípravě: (143, 30) počet vah modelu: 30
Co která metoda dělá
Spoj metodu s tím, co udělá.
Co se stane s prvním krokem pipeline, když zavoláš pipe.predict(X_test)?
predict volá u přípravných kroků pouze transform. Přesně proto pipeline únik z testu nepustí.
Smíšená data: ColumnTransformer
Skutečné tabulky mají čísla i kategorie a v obou můžou chybět hodnoty. Každý typ sloupce potřebuje jinou přípravu. ColumnTransformer pošle každou skupinu sloupců vlastní cestou a výsledky zase spojí:
vek, utrata -> doplň medián -> standardizuj ─┐
├─> spoj -> model
mesto, tarif -> doplň -> one-hot ─┘One-hot kódování udělá z kategorie sloupce s nulami a jedničkami, jeden za každou hodnotu. handle_unknown="ignore" je pojistka: město, které model v tréninku neviděl, dostane samé nuly místo pádu aplikace. Na konci ukázky takového zákazníka opravdu pošleme, a to ještě bez vyplněné útraty.
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import Pipeline, make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
rng = np.random.default_rng(0)
n = 300
df = pd.DataFrame({
"vek": rng.integers(18, 80, n).astype(float),
"utrata": rng.gamma(2.0, 500.0, n),
"mesto": rng.choice(["Praha", "Brno", "Ostrava"], n),
"tarif": rng.choice(["zaklad", "plus"], n),
})
skore = df["utrata"] / 1000 + (df["tarif"] == "plus") * 1.0 + rng.normal(0, 0.5, n)
y = (skore > skore.median()).astype(int).to_numpy()
df.loc[rng.random(n) < 0.1, "utrata"] = np.nan
df.loc[rng.random(n) < 0.05, "mesto"] = None
priprava = ColumnTransformer([
("cisla", make_pipeline(SimpleImputer(strategy="median"), StandardScaler()), ["vek", "utrata"]),
("kategorie", make_pipeline(
SimpleImputer(strategy="most_frequent"),
OneHotEncoder(handle_unknown="ignore"),
), ["mesto", "tarif"]),
])
pipe = Pipeline([("priprava", priprava), ("model", LogisticRegression(max_iter=1000))])
cv = StratifiedKFold(5, shuffle=True, random_state=0)
print(f"křížová validace: {cross_val_score(pipe, df, y, cv=cv).mean():.3f}")
pipe.fit(df, y)
print("sloupce po přípravě:", list(pipe[:-1].get_feature_names_out()))
novy = pd.DataFrame([{"vek": 30.0, "utrata": np.nan, "mesto": "Plzeň", "tarif": "plus"}])
print("nový zákazník:", pipe.predict(novy))
křížová validace: 0.830 sloupce po přípravě: ['cisla__vek', 'cisla__utrata', 'kategorie__mesto_Brno', 'kategorie__mesto_Ostrava', 'kategorie__mesto_Praha', 'kategorie__mesto_None', 'kategorie__tarif_plus', 'kategorie__tarif_zaklad'] nový zákazník: [1]
Celá příprava je teď uvnitř jednoho objektu. Medián, slovník měst i měřítko se v každém foldu učí jen z trénovací části a ty ses o to nemusel starat.
Ladění celého řetězu
Pipeline se ladí jako každý jiný model. Parametr konkrétního kroku zapíšeš jako krok__parametr se dvěma podtržítky. Sílu regularizace i počet vybraných příznaků tak hledáš společně a výběr se znovu provede pro každou kombinaci a každý fold.
from sklearn.datasets import load_breast_cancer
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
X, y = load_breast_cancer(return_X_y=True)
pipe = make_pipeline(
StandardScaler(),
SelectKBest(f_classif),
LogisticRegression(max_iter=1000),
)
mrizka = {
"selectkbest__k": [5, 10, 30],
"logisticregression__C": [0.1, 1.0, 10.0],
}
hledani = GridSearchCV(pipe, mrizka, cv=StratifiedKFold(3, shuffle=True, random_state=0))
hledani.fit(X, y)
print(hledani.best_params_)
print(round(hledani.best_score_, 3))
{'logisticregression__C': 1.0, 'selectkbest__k': 30}
0.977Doplň název parametru
Krok se jmenuje model. Doplň klíč mřížky pro jeho parametr C a objekt, který se má ladit.
Když ti hotové kroky nestačí, napiš vlastní. Dědí z BaseEstimator a TransformerMixin. Tenhle ořezává extrémní hodnoty podle kvantilů, které se naučí z tréninku. Hranice je jen další parametr, takže by šla ladit také.
import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
class Orez(BaseEstimator, TransformerMixin):
def __init__(self, dolni=0.01, horni=0.99):
self.dolni = dolni
self.horni = horni
def fit(self, X, y=None):
self.meze_ = np.quantile(X, [self.dolni, self.horni], axis=0)
return self
def transform(self, X):
return np.clip(X, self.meze_[0], self.meze_[1])
X, y = load_breast_cancer(return_X_y=True)
pipe = make_pipeline(Orez(horni=0.98), StandardScaler(), LogisticRegression(max_iter=1000))
cv = StratifiedKFold(3, shuffle=True, random_state=0)
print(list(pipe.named_steps))
print(round(cross_val_score(pipe, X, y, cv=cv).mean(), 3))
['orez', 'standardscaler', 'logisticregression'] 0.975
Pod kapotou · co pipeline dělá pod kapotou
clone.cross_val_scoreiGridSearchCVpřed každým tréninkem volajísklearn.base.clone. Ten vezme jen parametry zget_paramsa vyrobí nezatrénovaný objekt. Proto smí__init__pouze ukládat argumenty pod stejnými jmény a veškerá logika patří dofit. Naučené atributy končí podtržítkem, podle tohocheck_is_fittedpoznává natrénovaný objekt.memory. Při ladění se stejné přípravné kroky počítají znovu a znovu.Pipeline(kroky, memory="cache/")jejich výsledky ukládá přes joblib, takže se u drahých transformací mřížka zrychlí.- Záměna celého kroku. Krok je také parametr:
{"vyber": ["passthrough", SelectKBest(k=10)]}v mřížce vyzkouší variantu bez výběru i s ním. set_output(transform="pandas")nechá kroky vracet DataFrame se jmény sloupců, což výrazně ulehčí ladění.- Vnořené názvy se skládají dál:
priprava__cisla__simpleimputer__strategy. Všechny platné klíče vypíšepipe.get_params().keys(). TargetEncoder(od verze 1.3) kóduje kategorii průměrem cíle, tedy přímo zy. Aby neunikal,fit_transformpoužívá vnitřní křížové proložení, takžefit(X, y).transform(X)dává jiné výsledky nežfit_transform(X, y). V pipeline to vyjde správně samo.- Převzorkování (SMOTE a spol.) smí běžet jen na tréninku a jen při
fit. BěžnýPipelineto neumí, proto existujeimblearn.pipeline.Pipeline.
Únik, který pipeline nechytí
Pipeline hlídá jen pořadí kroků. Na to, že jsou špatná samotná data, ji nenapadne si stěžovat. Dvě nejčastější situace.
Duplicity a skupiny. Každý řádek tu máme dvakrát, s nepatrnou odchylkou. Třídy jsou zase čistá náhoda. Klasifikátor nejbližšího souseda prostě opíše třídu nejpodobnějšího trénovacího řádku. Porovnáme náhodné dělení s dělením po skupinách, kde obě kopie zůstanou na stejné straně.
import numpy as np
rng = np.random.default_rng(0)
n = 200
zaklad = rng.normal(size=(n, 10))
y_zaklad = rng.integers(0, 2, n)
X = np.vstack([zaklad, zaklad + rng.normal(0, 0.01, (n, 10))])
y = np.concatenate([y_zaklad, y_zaklad])
skupina = np.concatenate([np.arange(n), np.arange(n)])
def soused(X_tr, y_tr, X_te, y_te):
d = ((X_te[:, None] - X_tr[None]) ** 2).sum(axis=2)
return np.mean(y_tr[d.argmin(axis=1)] == y_te)
idx = rng.permutation(2 * n)
tr, te = idx[:n], idx[n:]
print(f"náhodné dělení: {soused(X[tr], y[tr], X[te], y[te]):.2f}")
v_testu = np.isin(skupina, rng.permutation(n)[:n // 2])
print(f"dělení po skupinách: {soused(X[~v_testu], y[~v_testu], X[v_testu], y[v_testu]):.2f}")
náhodné dělení: 0.76 dělení po skupinách: 0.55
Příznak z budoucnosti. Přidáme do dat sloupec, který je skoro kopií odpovědi, jako by v tabulce zůstalo „datum vyřízení reklamace“. Křížová validace ho neodhalí, protože únik je v každém foldu. Prozradí ho důležitost příznaků: jeden jediný sloupec dělá skoro všechno. Sleduj, jak skočí skóre po jeho přidání a který sloupec vyhraje.
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.tree import DecisionTreeClassifier
X, y = make_classification(n_samples=400, n_features=8, n_informative=3, flip_y=0.15, random_state=0)
rng = np.random.default_rng(0)
podezrely = np.where(rng.random(400) < 0.03, 1 - y, y)
X_unik = np.column_stack([X, podezrely])
strom = DecisionTreeClassifier(max_depth=3, random_state=0)
cv = StratifiedKFold(5, shuffle=True, random_state=0)
print(f"bez podezřelého sloupce: {cross_val_score(strom, X, y, cv=cv).mean():.3f}")
print(f"s podezřelým sloupcem: {cross_val_score(strom, X_unik, y, cv=cv).mean():.3f}")
strom.fit(X_unik, y)
print("důležitosti:", strom.feature_importances_.round(2))
bez podezřelého sloupce: 0.795 s podezřelým sloupcem: 0.965 důležitosti: [0. 0. 0. 0. 0.01 0.01 0.01 0. 0.97]
Model předpovídá, zda pacient bude hospitalizován. Nejdůležitější příznak je „počet dní na lůžku“. Co s tím?
Počet dní na lůžku vznikne až po hospitalizaci. Je to únik z budoucnosti a žádná pipeline ani standardizace ho neopraví.
Pod kapotou · model v produkci
Pipeline ukládáš jako celek, tím zmizí celá třída chyb, kdy se příprava v tréninku a v provozu rozjede (training-serving skew).
import joblib
joblib.dump(pipe, "model.joblib")
pipe = joblib.load("model.joblib")
pipe.predict(novy_radek)joblibpoužívá pickle. Načtení souboru může spustit libovolný kód, takže nikdy nenačítej model z nedůvěryhodného zdroje. Bezpečnější formát nabízískops.io, přenositelný mezi jazyky je ONNX.- Pickle není stabilní mezi verzemi scikit-learn. Spolu s modelem si ulož přesné verze knihoven, kód vlastních transformerů a hash trénovacích dat. Vlastní třída se navíc musí dát importovat ze stejné cesty jako při ukládání.
- U dat v čase je potřeba point-in-time join: k řádku se smí připojit jen stav, který platil v jeho okamžiku. Agregace typu „průměrná útrata zákazníka“ počítaná z celé historie je nejčastější únik v produkčních systémech. Feature story tohle řeší přímo.
- Standardizace přes celou tabulku většinou zkreslí výsledek jen málo. Nebezpečné jsou kroky, které se dívají na
y: výběr příznaků, target encoding, převzorkování. Disciplína se ale vyplatí vždy, protože se pak o velikosti úniku nemusíš dohadovat.