0 dní v řadě · 0 bodů

Strojové učení · 35 min

Pipelines a únik dat

Proč model s fantastickým skóre často podvádí, jak únik dat odhalit a jak mu předejít pomocí pipeline ve scikit-learn.

Hloubka
Úkoly
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:

PodobaPříklad
Příprava dat viděla i testovací řádkyprů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 testuduplicitní řá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ýstup
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:

text
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í.

Roztřiď

Únik, nebo v pořádku?

Roztřiď postupy.

fit se učí, transform používá

Skoro všechno ve scikit-learn má dvě metody:

  • fit se učí z dat a zapamatuje si, co zjistil.
  • transform to 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())
Výstup
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.

Úkol

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
Výstup
Najdi chybu

Kdo si půjčil test?

Kód má standardizovat data bez úniku. Jeden řádek to porušuje.

Slož kód

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ř:

text
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}")
Výstup
přesnost s pipeline: 0.48

Správně nudný výsledek kolem padesáti procent. Šum zůstal šumem.

Úkol

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))
Výstup

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ýstup
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])
Výstup
křížová validace: 0.981
test: 0.958
kroky: ['standardscaler', 'logisticregression']
tvar po přípravě: (143, 30)
počet vah modelu: 30
Spoj dvojice

Co která metoda dělá

Spoj metodu s tím, co udělá.

Kvíz

Co se stane s prvním krokem pipeline, když zavoláš pipe.predict(X_test)?

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í:

text
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))
Výstup
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))
Výstup
{'logisticregression__C': 1.0, 'selectkbest__k': 30}
0.977
Doplň

Doplň 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))
Výstup
['orez', 'standardscaler', 'logisticregression']
0.975
Pod kapotou · co pipeline dělá pod kapotou
  • clone. cross_val_score i GridSearchCV před každým tréninkem volají sklearn.base.clone. Ten vezme jen parametry z get_params a vyrobí nezatrénovaný objekt. Proto smí __init__ pouze ukládat argumenty pod stejnými jmény a veškerá logika patří do fit. Naučené atributy končí podtržítkem, podle toho check_is_fitted pozná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íše pipe.get_params().keys().
  • TargetEncoder (od verze 1.3) kóduje kategorii průměrem cíle, tedy přímo z y. Aby neunikal, fit_transform používá vnitřní křížové proložení, takže fit(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ý Pipeline to neumí, proto existuje imblearn.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}")
Výstup
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))
Výstup
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]
Kvíz

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?

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).

python
import joblib

joblib.dump(pipe, "model.joblib")
pipe = joblib.load("model.joblib")
pipe.predict(novy_radek)
  • joblib použí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.
Kartičky

Opakování