Lidsky řečeno
Učitel rozdá před písemkou přesné zadání i s řešením. Druhý den mají všichni jedničku. Znamená to, že látce rozumí? Nevíš. Možná se jen nabiflovali odpovědi. Zjistíš to až otázkami, které ještě neviděli. U modelů je to stejné: část dat schováš a ukážeš mu ji až při zkoušení.
Jednička z taháku
Cílem modelu není popsat minulost. Má fungovat na nových datech. Této schopnosti se říká generalizace a z dat, na kterých se model učil, ji nezměříš.
Důkaz je snadný. Vyrobíme data, kde je správná odpověď čistě hod mincí, takže se z nich nic naučit nedá. Metoda nejbližšího souseda z minulé lekce přesto dosáhne na trénovacích datech dokonalého výsledku.
import numpy as np
rng = np.random.default_rng(7)
X = rng.normal(size=(400, 2))
y = rng.integers(0, 2, size=400) # odpovědi jsou čistá náhoda
X_train, y_train = X[:300], y[:300]
X_test, y_test = X[300:], y[300:]
def predict_1nn(X_ref, y_ref, X_dotaz):
d = ((X_dotaz[:, None] - X_ref[None, :]) ** 2).sum(axis=2)
return y_ref[d.argmin(axis=1)]
na_trenovacich = (predict_1nn(X_train, y_train, X_train) == y_train).mean()
na_testovacich = (predict_1nn(X_train, y_train, X_test) == y_test).mean()
print(f"trénovací data: {na_trenovacich:.1%}")
print(f"testovací data: {na_testovacich:.1%}")
trénovací data: 100.0% testovací data: 49.0%
Na trénovacích datech je každý bod sám sobě nejbližším sousedem, takže stoprocentní úspěch je zaručený. Na nových datech model jen hádá. Kdybys měřil jen první číslo, nasadil bys program, který neumí nic.
Proto se data dělí:
- trénovací množina slouží k učení,
- testovací množina se schová a použije se jen na závěrečné měření.
všechna data
+--------------------------------------+----------+
| trénovací | testovací|
| 80 % | 20 % |
+--------------------------------------+----------+
model se z nich učí zkouškaPoměr 80 : 20 je zvyk, ne zákon. O tom, kolik testovacích dat stačí, rozhoduje jejich počet, ne procento.
Model má na trénovacích datech 99 % a na testovacích 61 %. Co to nejspíš znamená?
Velký rozdíl mezi oběma čísly je typický příznak přeučení. Podrobně ho rozebírá lekce Přeučení, bias a variance.
Nejdřív zamíchat
Rozdělit data prostým „posledních 20 % je test“ je past. Data bývají seřazená: podle data, podle kategorie, podle toho, jak je někdo exportoval. Takhle dopadne dataset, kde jsou třídy za sebou.
import numpy as np
y = np.array([0] * 50 + [1] * 50 + [2] * 50)
hranice = int(len(y) * 0.8)
y_train, y_test = y[:hranice], y[hranice:]
print("třídy v tréninku:", np.unique(y_train))
print("třídy v testu: ", np.unique(y_test))
rng = np.random.default_rng(0)
poradi = rng.permutation(len(y))
y_train, y_test = y[poradi[:hranice]], y[poradi[hranice:]]
print("po zamíchání, počty v testu:", np.bincount(y_test))
třídy v tréninku: [0 1 2] třídy v testu: [2] po zamíchání, počty v testu: [ 8 12 10]
Bez míchání je v testu jediná třída. O prvních dvou se nedozvíš vůbec nic a třetí model při tréninku skoro neviděl. Po zamíchání jsou v testu zastoupené všechny.
Míchat se musí X a y stejně, jinak se rozpojí vlastnosti od odpovědí. Proto se nemíchají data samotná, ale pole pozic: rng.permutation(n) vrátí čísla 0 až n-1 v náhodném pořadí a tím pak indexuješ obě pole.
Vlastní rozdělení dat
Napiš rozdel(X, y, test_size, seed), která vrátí čtveřici X_train, X_test, y_train, y_test. Data náhodně zamíchej generátorem np.random.default_rng(seed). Do testu dej int(len(X) * test_size) příkladů. Dvojice X a y musí zůstat pohromadě a stejný seed musí dát stejný výsledek.
import numpy as np
def rozdel(X, y, test_size, seed):
# doplň
return X, X, y, y
X = np.arange(20).reshape(10, 2)
y = X[:, 0] * 10
print(rozdel(X, y, 0.5, 0)[2])
train_test_split
Ve scikit-learn to za tebe udělá jedna funkce. Tři parametry stojí za zapamatování:
test_sizeurčuje velikost testu,random_stateje semínko náhody, díky kterému dostaneš pokaždé stejné rozdělení,stratify=yzachová poměr tříd v obou částech.
Dataset breast_cancer obsahuje měření nádorů a informaci, zda jsou zhoubné.
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
print("trénink:", X_train.shape, " test:", X_test.shape)
print(f"podíl třídy 1 celkem: {y.mean():.3f}")
print(f"podíl třídy 1 v tréninku: {y_train.mean():.3f}")
print(f"podíl třídy 1 v testu: {y_test.mean():.3f}")
trénink: (455, 30) test: (114, 30) podíl třídy 1 celkem: 0.627 podíl třídy 1 v tréninku: 0.626 podíl třídy 1 v testu: 0.632
Všechny tři podíly by měly vyjít skoro stejně. Pozor na pořadí návratových hodnot: nejdřív obě části X, pak obě části y.
Stratifikace je nejdůležitější u vzácných tříd. Když je pozitivních příkladů málo, náhoda může rozhodnout, že jich do testu padne pár, nebo žádný. Levý sloupec ukazuje běžné dělení, pravý stratifikované.
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(n_samples=100, weights=[0.9], flip_y=0, random_state=0)
print("vzácných příkladů celkem:", int(y.sum()))
for seed in range(6):
obycejne = train_test_split(X, y, test_size=0.2, random_state=seed)[3]
strat = train_test_split(X, y, test_size=0.2, random_state=seed, stratify=y)[3]
print(f"seed {seed}: {int(obycejne.sum())} {int(strat.sum())}")
vzácných příkladů celkem: 9 seed 0: 0 2 seed 1: 2 2 seed 2: 2 2 seed 3: 1 2 seed 4: 2 2 seed 5: 1 2
V levém sloupci čísla kolísají, v pravém zůstávají stejná. Hodnotit vzácnou třídu podle testu s jedním jejím zástupcem je jako posuzovat kuchaře podle jediného sousta.
Rozděl kosatce
Rozděl dataset iris tak, aby 20 % šlo do testu a poměr druhů zůstal zachovaný. Použij random_state=0. Výsledky ulož do X_train, X_test, y_train, y_test.
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
# doplň
Třetí hromádka: validace
Máš pět modelů a chceš vybrat nejlepší. Nabízí se porovnat je na testu. Jenže tím se test stává součástí učení: rozhodnutí se opřelo o jeho výsledek a ten už není nezávislý.
Jak velký to má dopad, ukáže extrémní případ. Pět set „modelů“ tady jen hádá. Vybereme ten, kterému to na testu vyšlo nejlíp, a pak ho zkusíme na úplně nových datech.
import numpy as np
rng = np.random.default_rng(0)
n, n_modelu = 100, 500
y_test = rng.integers(0, 2, size=n)
y_nova = rng.integers(0, 2, size=n)
tipy_test = rng.integers(0, 2, size=(n_modelu, n))
tipy_nova = rng.integers(0, 2, size=(n_modelu, n))
skore = (tipy_test == y_test).mean(axis=1)
vitez = skore.argmax()
print(f"průměrný model na testu: {skore.mean():.1%}")
print(f"vítěz na testu: {skore[vitez]:.1%}")
print(f"vítěz na nových datech: {(tipy_nova[vitez] == y_nova).mean():.1%}")
průměrný model na testu: 49.9% vítěz na testu: 67.0% vítěz na nových datech: 54.0%
Vítěz vypadá, jako by něco uměl, a přitom měl jen štěstí. Čím víc pokusů na stejném testu uděláš, tím optimističtější číslo dostaneš. V praxi to dělá každý, kdo ladí nastavení a po každé změně se dívá na test.
Řešením je třetí část, validační množina:
| Část | K čemu slouží | Kolikrát ji použiješ |
|---|---|---|
| trénovací | učení parametrů modelu | pořád |
| validační | výběr modelu a jeho nastavení | často |
| testovací | závěrečný odhad kvality | jednou, na konci |
train_test_split se prostě zavolá dvakrát.
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
X, y = load_wine(return_X_y=True)
X_zbytek, X_test, y_zbytek, y_test = train_test_split(
X, y, test_size=0.2, random_state=0, stratify=y
)
X_train, X_val, y_train, y_val = train_test_split(
X_zbytek, y_zbytek, test_size=0.25, random_state=0, stratify=y_zbytek
)
print("celkem:", len(X))
print("trénink:", len(X_train), " validace:", len(X_val), " test:", len(X_test))
celkem: 178 trénink: 106 validace: 36 test: 36
Když je dat málo, jedna validační část je zbytečně rozkolísaná. Lepší cestu ukáže křížová validace.
Proč má druhé volání v ukázce test_size=0.25, když chceme validaci o velikosti 20 % všech dat?
Druhé volání nevidí původní data, jen zbytek po odebrání testu. 0,25 krát 0,8 je 0,2.
Únik dat
Únik dat (data leakage) nastane, když se do tréninku dostane informace, kterou by model v reálném provozu neměl. Výsledky jsou skvělé, dokud model nenasadíš. Nejčastější podoby:
- Stejné záznamy v obou částech. Duplicity po spojení exportů.
- Stejná entita v obou částech. Několik snímků jednoho pacienta nebo fotky téhož objektu. Model pozná člověka, ne nemoc.
- Budoucnost v tréninku. Náhodné dělení časové řady dovolí učit se ze zítřka.
- Prozrazující sloupec. Třeba „datum výplaty pojistky“ při předpovídání, zda pojistná událost nastane.
- Úpravy spočítané ze všech dat. Průměry a měřítka se mají počítat jen z tréninku.
Duplicity jsou nejnázornější. Odpovědi jsou opět čistá náhoda, takže poctivý výsledek musí být kolem 50 %.
import numpy as np
def predict_1nn(X_ref, y_ref, X_dotaz):
d = ((X_dotaz[:, None] - X_ref[None, :]) ** 2).sum(axis=2)
return y_ref[d.argmin(axis=1)]
def zmer(X, y, seed=0):
poradi = np.random.default_rng(seed).permutation(len(X))
hranice = int(len(X) * 0.8)
train, test = poradi[:hranice], poradi[hranice:]
return (predict_1nn(X[train], y[train], X[test]) == y[test]).mean()
rng = np.random.default_rng(1)
X = rng.normal(size=(500, 3))
y = rng.integers(0, 2, size=500)
X_dvakrat, y_dvakrat = np.vstack([X, X]), np.concatenate([y, y])
print(f"bez duplicit: {zmer(X, y):.1%}")
print(f"s duplicitami: {zmer(X_dvakrat, y_dvakrat):.1%}")
_, jedinecne = np.unique(X_dvakrat, axis=0, return_index=True)
print(f"po odstranění: {zmer(X_dvakrat[jedinecne], y_dvakrat[jedinecne]):.1%}")
bez duplicit: 48.0% s duplicitami: 94.0% po odstranění: 51.0%
Bez duplicit je výsledek kolem 50 %, jak má být. S nimi model zdánlivě našel vzor v čisté náhodě, ve skutečnosti si jen vzpomněl na kopii. Duplicity se proto odstraňují před dělením.
Kde uniká informace?
Kód převádí vlastnosti na společné měřítko. Výsledek vypadá v pořádku, ale testovací data ovlivňují trénink. Klikni na řádky, kde se to děje.
U časových dat se nemíchá vůbec. Trénuje se na minulosti a testuje na tom, co přišlo potom, přesně jako v provozu.
Rozdělení podle času
Napiš rozdel_v_case(casy, podil_testu). casy je pole časových značek v libovolném pořadí. Vrať dvojici polí pozic train, test: do test patří int(len(casy) * podil_testu) nejnovějších záznamů, do train všechny ostatní.
import numpy as np
def rozdel_v_case(casy, podil_testu):
# doplň
return np.array([], dtype=int), np.array([], dtype=int)
print(rozdel_v_case(np.array([30, 10, 50, 20, 40]), 0.4))
Pod kapotou · jak přesné je číslo z testu
Přesnost na testu je odhad ze vzorku, takže má nejistotu. Pro n nezávislých příkladů a přesnost p je směrodatná chyba sqrt(p * (1 - p) / n) a přibližný 95% interval je asi 1,96násobek. Rozdíl dvou modelů na malém testu proto často nic neznamená. Při porovnání na stejném testu jsou chyby korelované, tam je vhodnější párový test, například McNemarův. Vedle počtu příkladů rozhoduje i nezávislost: tisíc řádků od deseti zákazníků nese mnohem méně informace než tisíc zákazníků.
import math
p = 0.90
for n in [50, 100, 1000, 10000]:
rozpeti = 1.96 * math.sqrt(p * (1 - p) / n)
print(f"n={n:<6} přesnost {p:.0%} ± {rozpeti:.1%}")
n=50 přesnost 90% ± 8.3% n=100 přesnost 90% ± 5.9% n=1000 přesnost 90% ± 1.9% n=10000 přesnost 90% ± 0.6%
Pod kapotou · stabilní dělení v produkci
permutation se semínkem je stabilní jen při stejném počtu řádků. Přibude-li jeden záznam, promíchá se všechno a staré testovací příklady se dostanou do tréninku. Odolnější je rozhodovat podle hashe identifikátoru entity: stejné ID padne vždy do stejné části, nové záznamy ty staré nepřesunou a všechny řádky jednoho zákazníka zůstanou pohromadě. Vestavěné hash() na to nepoužívej, u řetězců je kvůli PYTHONHASHSEED v každém procesu jiné. Vhodný je zlib.crc32 nebo hashlib.
import zlib
def v_testu(identifikator, podil=0.2):
return zlib.crc32(str(identifikator).encode()) % 1000 < podil * 1000
stari = [f"zakaznik-{i}" for i in range(10_000)]
novi = [f"zakaznik-{i}" for i in range(10_000, 12_000)]
test_pred = {z for z in stari if v_testu(z)}
test_po = {z for z in stari + novi if v_testu(z)}
print(f"podíl v testu: {len(test_pred) / len(stari):.3f}")
print("starý test zůstal celý:", test_pred <= test_po)
podíl v testu: 0.204 starý test zůstal celý: True
Ve scikit-learn řeší entity GroupShuffleSplit a GroupKFold, časové řady TimeSeriesSplit.