0 dní v řadě · 0 bodů

Strojové učení · 24 min

Trénovací a testovací data

Proč model nesmíš hodnotit na datech, ze kterých se učil, jak data správně rozdělit a jak nenápadně uniká informace z testu.

Hloubka
Úkoly
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%}")
Výstup
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í.
text
všechna data
+--------------------------------------+----------+
|              trénovací               | testovací|
|                 80 %                 |   20 %   |
+--------------------------------------+----------+
       model se z nich učí                zkouška

Poměr 80 : 20 je zvyk, ne zákon. O tom, kolik testovacích dat stačí, rozhoduje jejich počet, ne procento.

Kvíz

Model má na trénovacích datech 99 % a na testovacích 61 %. Co to nejspíš znamená?

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

Úkol

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

train_test_split

Ve scikit-learn to za tebe udělá jedna funkce. Tři parametry stojí za zapamatování:

  • test_size určuje velikost testu,
  • random_state je semínko náhody, díky kterému dostaneš pokaždé stejné rozdělení,
  • stratify=y zachová 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}")
Výstup
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())}")
Výstup
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.

Úkol

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

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%}")
Výstup
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:

ČástK čemu sloužíKolikrát ji použiješ
trénovacíučení parametrů modelupořád
validačnívýběr modelu a jeho nastaveníčasto
testovacízávěrečný odhad kvalityjednou, 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))
Výstup
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.

Kvíz

Proč má druhé volání v ukázce test_size=0.25, když chceme validaci o velikosti 20 % všech dat?

Ú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%}")
Výstup
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.

Najdi chybu

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.

Úkol

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))
Výstup
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%}")
Výstup
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)
Výstup
podíl v testu: 0.204
starý test zůstal celý: True

Ve scikit-learn řeší entity GroupShuffleSplit a GroupKFold, časové řady TimeSeriesSplit.