Lidsky řečeno
Chceš zjistit, jak dobře někdo umí látku. Jedna písemka může dopadnout náhodou: padly zrovna otázky, které si včera přečetl. Spravedlivější je rozdělit učebnici na pět kapitol a zkoušet pětkrát. Pokaždé se učí ze čtyř kapitol a test píše z té páté. Každá kapitola si jednou zahraje zkoušejícího a výsledná známka je průměr. Přesně to dělá křížová validace.
Jedna písemka nestačí
V lekci o trénovacích a testovacích datech jsi data rozdělil jednou. Jenže výsledek pak závisí na tom, které řádky se do testu zrovna dostaly. U menších dat to dělá překvapivě velký rozdíl.
Vezmeme jednoduchý klasifikátor: pro každou třídu spočítá průměrný bod (centroid) a nový vzorek zařadí k tomu bližšímu. Stejná data i stejný model, mění se jen náhodné rozdělení 80 : 20.
import numpy as np
rng = np.random.default_rng(3)
n = 60
y = rng.integers(0, 2, n)
X = rng.normal(0, 1, (n, 2)) + y[:, None] * 1.2
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)
vysledky = []
for seed in range(10):
idx = np.random.default_rng(seed).permutation(n)
test, trenink = idx[:12], idx[12:]
vysledky.append(presnost(X[trenink], y[trenink], X[test], y[test]))
print("přesnosti:", np.round(vysledky, 2))
print(f"nejhorší {min(vysledky):.2f}, nejlepší {max(vysledky):.2f}")
přesnosti: [0.83 0.75 0.58 0.67 0.75 0.67 0.75 0.92 0.83 0.83] nejhorší 0.58, nejlepší 0.92
Rozpětí mezi nejhorším a nejlepším rozdělením je obrovské. Kdybys zkusil jen jedno, mohl sis model zbytečně zavrhnout, nebo se z něj naopak radovat bez důvodu. A kdybys dvě verze modelu porovnával každou na jiném rozdělení, nevěděl bys, co vlastně měříš.
K-fold: každý kousek jednou zkouší
Křížová validace (cross-validation, zkráceně CV) to řeší opakováním. Nejběžnější varianta se jmenuje k-fold:
- Data náhodně rozděl na
kstejně velkých dílů. Dílu se říká fold. - Jeden díl odlož na ověření, na zbytku natrénuj nový model a změř ho.
- Opakuj tak, aby si každý díl jednou zahrál ověřovací.
- Výsledky zprůměruj.
k = 5 fold 1 fold 2 fold 3 fold 4 fold 5
kolo 1 [ test ] trén trén trén trén
kolo 2 trén [ test ] trén trén trén
kolo 3 trén trén [ test ] trén trén
kolo 4 trén trén trén [ test ] trén
kolo 5 trén trén trén trén [ test ]Když se počet řádků nedá dělit beze zbytku, np.array_split dá o jeden řádek víc prvním dílům. Tipni si, co vypíše tohle.
import numpy as np
foldy = np.array_split(np.arange(23), 5)
print([len(f) for f in foldy])
[5, 5, 5, 4, 4]
Teď celý k-fold. Číslo k nastavíš posuvníkem. Kromě průměru sleduj i směrodatnou odchylku mezi foldy, tedy jak moc výsledky kolísají.
import numpy as np
rng = np.random.default_rng(3)
n = 60
y = rng.integers(0, 2, n)
X = rng.normal(0, 1, (n, 2)) + y[:, None] * 1.2
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 k_fold(n, k, seed=0):
idx = np.random.default_rng(seed).permutation(n)
for val in np.array_split(idx, k):
yield np.setdiff1d(idx, val), val
skore = []
for trenink, val in k_fold(n, int(k)):
skore.append(presnost(X[trenink], y[trenink], X[val], y[val]))
print("po foldech:", np.round(skore, 2))
print(f"průměr {np.mean(skore):.3f}, odchylka {np.std(skore):.3f}")
po foldech: [0.83 0.75 0.75 0.67 0.67] průměr 0.733, odchylka 0.062
Jak zvolit k? Běžné hodnoty jsou 5 a 10. Čím větší k, tím víc dat má každý model k tréninku, takže se blíží finálnímu modelu, ale výpočet trvá déle a ověřovací díly jsou menší. Trénuješ totiž k modelů místo jednoho.
Rozděl data na foldy
Napiš funkci foldy(n, k), která vrátí seznam k dvojic (trenink, val). Obě části jsou pole indexů. Každý index od 0 do n - 1 musí být právě v jedné části val a v dané dvojici nesmí být zároveň v trenink i val. Míchat nemusíš.
import numpy as np
def foldy(n, k):
return []
Podezřele skvělé výsledky
Kolega napsal vlastní k-fold a jeho model má na validaci skoro dokonalé skóre. Najdi proč.
Jak dělit: třídy, skupiny a čas
Náhodné dělení předpokládá, že jsou řádky na sobě nezávislé a že na pořadí nezáleží. To často neplatí.
Vzácná třída. Když je kladných případů pět z padesáti, může se stát, že v některém foldu nebude ani jeden. Stratifikace rozdělí každou třídu zvlášť, takže poměr tříd zůstane ve všech foldech stejný.
import numpy as np
y = np.array([1] * 5 + [0] * 45)
rng = np.random.default_rng(1)
idx = rng.permutation(len(y))
obycejne = [int(y[f].sum()) for f in np.array_split(idx, 5)]
kladne = rng.permutation(np.flatnonzero(y == 1))
zaporne = rng.permutation(np.flatnonzero(y == 0))
stratifikovane = [
int(y[np.concatenate([a, b])].sum())
for a, b in zip(np.array_split(kladne, 5), np.array_split(zaporne, 5))
]
print("kladných ve foldech, obyčejně: ", obycejne)
print("kladných ve foldech, stratifikace: ", stratifikovane)
kladných ve foldech, obyčejně: [1, 1, 1, 2, 0] kladných ve foldech, stratifikace: [1, 1, 1, 1, 1]
Skupiny. Máš deset snímků od každého pacienta. Když se snímky téhož člověka dostanou do tréninku i do validace, model pozná jeho, ne nemoc. GroupKFold drží každou skupinu pohromadě.
Čas. Předpovídáš prodeje na příští týden. Trénovat na budoucnosti a ověřovat na minulosti je podvod, i když nechtěný. TimeSeriesSplit vždy trénuje na starším a ověřuje na novějším.
Ve scikit-learn tomu slouží hotové třídy zvané splittery. Všechny mají metodu split, která vrací indexy. V ukázce si všimni, že u GroupKFold je každé písmeno skupiny celé na jedné straně a že u TimeSeriesSplit jsou ověřovací indexy vždy až za trénovacími.
import numpy as np
from sklearn.model_selection import GroupKFold, KFold, StratifiedKFold, TimeSeriesSplit
X = np.arange(12).reshape(-1, 1)
y = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1])
skupiny = np.array(list("aaabbbcccddd"))
delice = {
"KFold": KFold(3, shuffle=True, random_state=0),
"StratifiedKFold": StratifiedKFold(3, shuffle=True, random_state=0),
"GroupKFold": GroupKFold(3),
"TimeSeriesSplit": TimeSeriesSplit(3),
}
for jmeno, cv in delice.items():
print(jmeno)
navic = {"groups": skupiny} if jmeno == "GroupKFold" else {}
for tr, va in cv.split(X, y, **navic):
print(" trénink", tr.tolist(), " validace", va.tolist())
KFold trénink [0, 1, 2, 3, 5, 7, 8, 9] validace [4, 6, 10, 11] trénink [0, 3, 4, 5, 6, 9, 10, 11] validace [1, 2, 7, 8] trénink [1, 2, 4, 6, 7, 8, 10, 11] validace [0, 3, 5, 9] StratifiedKFold trénink [0, 3, 4, 5, 6, 8, 9, 11] validace [1, 2, 7, 10] trénink [0, 1, 2, 4, 5, 7, 9, 10] validace [3, 6, 8, 11] trénink [1, 2, 3, 6, 7, 8, 10, 11] validace [0, 4, 5, 9] GroupKFold trénink [3, 4, 5, 6, 7, 8] validace [0, 1, 2, 9, 10, 11] trénink [0, 1, 2, 3, 4, 5, 9, 10, 11] validace [6, 7, 8] trénink [0, 1, 2, 6, 7, 8, 9, 10, 11] validace [3, 4, 5] TimeSeriesSplit trénink [0, 1, 2] validace [3, 4, 5] trénink [0, 1, 2, 3, 4, 5] validace [6, 7, 8] trénink [0, 1, 2, 3, 4, 5, 6, 7, 8] validace [9, 10, 11]
Který splitter použít?
Roztřiď úlohy podle způsobu dělení, který jim sedí nejlépe.
Hotová křížová validace
Celou smyčku za tebe udělá cross_val_score. Model mu předáš nenatrénovaný a pro každý fold si vyrobí čerstvou kopii. cross_validate umí víc: měří i čas a na přání trénovací skóre, takže rovnou vidíš případné přeučení.
Sleduj dvě věci: jak moc se liší jednotlivé foldy a jak velký je rozdíl mezi trénovacím a validačním průměrem.
from sklearn.datasets import load_wine
from sklearn.model_selection import StratifiedKFold, cross_val_score, cross_validate
from sklearn.tree import DecisionTreeClassifier
X, y = load_wine(return_X_y=True)
model = DecisionTreeClassifier(max_depth=3, random_state=0)
cv = StratifiedKFold(5, shuffle=True, random_state=0)
skore = cross_val_score(model, X, y, cv=cv)
print("po foldech:", skore.round(3))
print(f"průměr {skore.mean():.3f}, odchylka {skore.std():.3f}")
vysledek = cross_validate(model, X, y, cv=cv, return_train_score=True)
print(f"trénink {vysledek['train_score'].mean():.3f}, validace {vysledek['test_score'].mean():.3f}")
po foldech: [0.944 0.861 0.972 0.971 0.943] průměr 0.938, odchylka 0.041 trénink 0.993, validace 0.938
Pod kapotou · co křížová validace opravdu odhaduje
Výchozí dělení. cv=5 u klasifikátoru znamená StratifiedKFold a u regresoru KFold, v obou případech bez míchání. Když máš regresní data seřazená třeba podle data nebo ceny, dostaneš foldy s jiným rozdělením. Předej raději explicitní splitter s shuffle=True a pevným random_state, modely pak porovnáváš na identických foldech.
Odchylka není interval spolehlivosti. Trénovací množiny se mezi foldy z velké části překrývají, takže skóre nejsou nezávislá. Bengio a Grandvalet (2004) ukázali, že pro varianci k-fold odhadu neexistuje univerzální nestranný odhad. Vzorec std / √k bývá příliš optimistický. Při porovnávání dvou modelů se dívej na rozdíly po foldech na stejném dělení.
Leave-one-out zadarmo. Extrém k = n vypadá drahý, ale u ridge vystačíš s jediným rozkladem. Platí e_i = (y_i − ŷ_i) / (1 − H_ii), kde H = X(XᵀX + λI)⁻¹Xᵀ. Tenhle trik používá RidgeCV.
import numpy as np
rng = np.random.default_rng(0)
X = rng.normal(size=(30, 4))
y = X @ np.array([1.0, -2.0, 0.5, 0.0]) + rng.normal(0, 0.5, 30)
lam = 2.0
A = X.T @ X + lam * np.eye(4)
H = X @ np.linalg.solve(A, X.T)
zkratka = (y - H @ y) / (1 - np.diag(H))
poctive = []
for i in range(30):
maska = np.arange(30) != i
Xt, yt = X[maska], y[maska]
w = np.linalg.solve(Xt.T @ Xt + lam * np.eye(4), Xt.T @ yt)
poctive.append(y[i] - X[i] @ w)
print("MSE zkratkou:", round(float(np.mean(zkratka**2)), 6))
print("MSE poctivě: ", round(float(np.mean(np.square(poctive))), 6))
print("shoda:", np.allclose(zkratka, poctive))
MSE zkratkou: 0.326976 MSE poctivě: 0.326976 shoda: True
Předpovědi mimo fold. cross_val_predict vrátí pro každý řádek předpověď modelu, který ten řádek neviděl. Hodí se pro matici záměn nebo jako vstup pro stacking. Skóre spočítané z nich není totéž co průměr skóre po foldech, a dokumentace před takovou záměnou výslovně varuje.
Ladění hyperparametrů
Parametry se model učí sám z dat, třeba váhy regrese. Hyperparametry nastavuješ ty předem: hloubku stromu, sílu regularizace λ. Ladění znamená vyzkoušet různé hodnoty a vybrat tu nejlepší podle křížové validace, nikdy podle testu.
Ručně je to dvojitá smyčka. Tady hledáme λ pro ridge regresi. Vedle průměrné chyby vypisujeme standardní chybu průměru (odchylka / √k), hrubý ukazatel toho, jak moc průměru věřit.
import numpy as np
rng = np.random.default_rng(0)
x = rng.uniform(-1, 1, 40)
y = np.sin(3 * x) + rng.normal(0, 0.25, 40)
X = np.vander(x, 11, increasing=True)
def ridge(X, y, lam):
pokuta = np.eye(X.shape[1])
pokuta[0, 0] = 0
return np.linalg.solve(X.T @ X + lam * pokuta, X.T @ y)
idx = np.random.default_rng(1).permutation(40)
foldy = np.array_split(idx, 5)
lamy = [1e-6, 1e-4, 1e-2, 1, 100]
prumery = []
print(" λ chyba ± SE")
for lam in lamy:
chyby = []
for val in foldy:
tr = np.setdiff1d(idx, val)
w = ridge(X[tr], y[tr], lam)
chyby.append(np.mean((X[val] @ w - y[val]) ** 2))
prumery.append(np.mean(chyby))
print(f"{lam:>8g} {np.mean(chyby):7.3f} {np.std(chyby) / np.sqrt(5):7.3f}")
nejlepsi = lamy[int(np.argmin(prumery))]
w_final = ridge(X, y, nejlepsi)
print("vítěz: λ =", nejlepsi)
λ chyba ± SE
1e-06 0.111 0.012
0.0001 0.102 0.009
0.01 0.092 0.008
1 0.177 0.038
100 0.521 0.063
vítěz: λ = 0.01Poslední krok je důležitý: po výběru hyperparametru se finální model natrénuje na všech datech. Modely z jednotlivých foldů byly jen měřicí pomůcka a zahazují se.
Křížová validace pro ridge
Doplň funkci cv_chyba(X, y, lam, k). Pro každý fold natrénuj ridge na trénovací části a spočítej MSE na validační. Vrať průměr přes všechny foldy jako číslo.
import numpy as np
def ridge(X, y, lam):
return np.linalg.solve(X.T @ X + lam * np.eye(X.shape[1]), X.T @ y)
def foldy(n, k):
idx = np.arange(n)
return [(np.setdiff1d(idx, val), val) for val in np.array_split(idx, k)]
def cv_chyba(X, y, lam, k):
return 0.0
Když je rozdíl mezi nejlepšími kandidáty menší než nejistota měření, nemá smysl věřit vítězi na tři desetinná místa. Zkušení lidé proto používají pravidlo jedné standardní chyby: najdi nejlepší model, přičti k jeho chybě jeho SE a z modelů pod touto hranicí vyber ten nejjednodušší, u ridge ten s největším λ.
Pravidlo jedné standardní chyby
Napiš funkci jedna_se(lamy, chyby, se). lamy je vzestupně seřazený seznam, chyby jsou průměrné CV chyby a se jejich standardní chyby. Najdi index nejmenší chyby, spočítej hranici chyba + se tohoto modelu a vrať největší λ, jehož chyba hranici nepřekračuje.
def jedna_se(lamy, chyby, se):
return lamy[0]
GridSearchCV a náhodné hledání
GridSearchCV vyzkouší všechny kombinace ze zadané mřížky a každou ohodnotí křížovou validací. Nakonec nejlepší kombinaci znovu natrénuje na všech předaných datech, takže se objekt dál chová jako hotový model.
Testovací data oddělíme hned na začátku a hledání je vůbec neuvidí. Porovnej best_score_ se skóre na testu a podívej se, jak blízko sebe jsou nejlepší kandidáti v tabulce.
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import GridSearchCV, StratifiedKFold, train_test_split
from sklearn.tree import DecisionTreeClassifier
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)
mrizka = {"max_depth": [2, 3, 4, 6, None], "min_samples_leaf": [1, 5, 20]}
hledani = GridSearchCV(
DecisionTreeClassifier(random_state=0),
mrizka,
cv=StratifiedKFold(5, shuffle=True, random_state=0),
)
hledani.fit(X_tr, y_tr)
print("nejlepší:", hledani.best_params_)
print(f"skóre z CV {hledani.best_score_:.3f}, na testu {hledani.score(X_te, y_te):.3f}")
v = hledani.cv_results_
for i in np.argsort(v["rank_test_score"])[:4]:
print(v["rank_test_score"][i], v["params"][i], round(v["mean_test_score"][i], 3))
nejlepší: {'max_depth': 4, 'min_samples_leaf': 5}
skóre z CV 0.944, na testu 0.923
1 {'max_depth': 4, 'min_samples_leaf': 5} 0.944
1 {'max_depth': 6, 'min_samples_leaf': 5} 0.944
1 {'max_depth': None, 'min_samples_leaf': 5} 0.944
4 {'max_depth': 3, 'min_samples_leaf': 5} 0.937Doplň ladění
Doplň název třídy pro hledání v mřížce, metodu, která ho spustí, a atribut s vítěznými hodnotami.
Mřížka má háček: počet kombinací se násobí. Pět parametrů po pěti hodnotách je 3125 kombinací a při pěti foldech přes 15 000 tréninků. Navíc většina parametrů obvykle moc nevadí. Náhodné hledání proto losuje kombinace a ty určíš jen jejich počet. Bergstra a Bengio (2012) ukázali, proč to funguje: když záleží hlavně na jednom parametru, mřížka 3 × 3 zkusí jen tři jeho různé hodnoty, kdežto devět náhodných pokusů devět.
Vyzkoušíme to na umělé úloze, kde záleží jen na parametru a a jeho nejlepší hodnota je pokaždé jinde. Měříme, jak daleko od optima v průměru skončíme.
import numpy as np
rng = np.random.default_rng(0)
pokusu = 5000
optima = rng.uniform(0, 1, pokusu)
mrizka_a = np.array([1 / 6, 1 / 2, 5 / 6])
vzdalenost_mrizka = np.abs(optima[:, None] - mrizka_a).min(axis=1)
nahodne_a = rng.uniform(0, 1, (pokusu, 9))
vzdalenost_nahodne = np.abs(optima[:, None] - nahodne_a).min(axis=1)
print(f"mřížka 3 × 3: {vzdalenost_mrizka.mean():.3f}")
print(f"9 náhodných bodů: {vzdalenost_nahodne.mean():.3f}")
mřížka 3 × 3: 0.083 9 náhodných bodů: 0.055
RandomizedSearchCV se používá stejně, jen místo seznamů můžeš dát rozdělení ze scipy.stats. Zde n_iter=15 znamená patnáct vylosovaných kombinací.
from scipy.stats import randint, uniform
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import RandomizedSearchCV, StratifiedKFold, train_test_split
from sklearn.tree import DecisionTreeClassifier
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)
rozdeleni = {
"max_depth": randint(1, 12),
"min_samples_leaf": randint(1, 40),
"max_features": uniform(0.2, 0.8),
}
hledani = RandomizedSearchCV(
DecisionTreeClassifier(random_state=0),
rozdeleni,
n_iter=15,
cv=StratifiedKFold(5, shuffle=True, random_state=0),
random_state=0,
)
hledani.fit(X_tr, y_tr)
print({k: round(float(v), 3) for k, v in hledani.best_params_.items()})
print(f"skóre z CV {hledani.best_score_:.3f}, na testu {hledani.score(X_te, y_te):.3f}")
{'max_depth': 6.0, 'max_features': 0.875, 'min_samples_leaf': 4.0}
skóre z CV 0.939, na testu 0.944Spustil jsi GridSearchCV na 40 kombinacích. Proč best_score_ obvykle trochu přeceňuje skutečnou kvalitu?
Každé skóre je zatížené náhodou. Když vybereš největší ze 40 hodnot, vybíráš i tu nejšťastnější. Tomu se říká optimistické zkreslení výběru.
Vítězova kletba
Tohle je nejzrádnější bod celé lekce. Když vybereš nejlepší z mnoha možností, změřené skóre vítěze je příliš dobré, i když každé jednotlivé měření bylo poctivé. V ukázce nejsou žádné modely, jen 300 hodů mincí. Žádný z nich nemůže umět víc než 50 %.
import numpy as np
rng = np.random.default_rng(0)
y_val = rng.integers(0, 2, 50)
modely = rng.integers(0, 2, (300, 50))
skore = (modely == y_val).mean(axis=1)
vitez = int(np.argmax(skore))
y_nova = rng.integers(0, 2, 10000)
predikce_nove = rng.integers(0, 2, 10000)
print(f"průměrný model na validaci: {skore.mean():.3f}")
print(f"vítěz na validaci: {skore[vitez]:.3f}")
print(f"vítěz na nových datech: {np.mean(predikce_nove == y_nova):.3f}")
průměrný model na validaci: 0.503 vítěz na validaci: 0.700 vítěz na nových datech: 0.496
Vítěz vypadá jako objev a na nových datech je zase házení mincí. U ladění je efekt menší, protože kandidáti nejsou nezávislí a mají i skutečné rozdíly, ale princip je stejný. Platí tedy:
- Výběr modelu a odhad jeho kvality nesmí používat stejná data.
- Stačí-li ti jeden odhad, drž stranou testovací množinu a sáhni na ni jednou, až na konci.
- Máš-li málo dat, použij vnořenou křížovou validaci. Vnitřní smyčka ladí, vnější měří.
vnější fold 1: [ test ] trén trén trén trén
└── uvnitř celé GridSearchCV s vlastními foldy
vnější fold 2: trén [ test ] trén trén trén
...V kódu je to nečekaně krátké: GridSearchCV je sám model, takže ho prostě předáš do cross_val_score. Porovnej vnořený odhad s optimističtějším best_score_. Rozdíl bývá malý, ale u malých dat a velkých mřížek roste.
from sklearn.datasets import load_wine
from sklearn.model_selection import GridSearchCV, StratifiedKFold, cross_val_score
from sklearn.tree import DecisionTreeClassifier
X, y = load_wine(return_X_y=True)
vnitrni = StratifiedKFold(3, shuffle=True, random_state=0)
vnejsi = StratifiedKFold(5, shuffle=True, random_state=1)
mrizka = {"max_depth": [2, 3, 5], "min_samples_leaf": [1, 10]}
hledani = GridSearchCV(DecisionTreeClassifier(random_state=0), mrizka, cv=vnitrni)
vnorene = cross_val_score(hledani, X, y, cv=vnejsi)
hledani.fit(X, y)
print(f"best_score_ (optimistické): {hledani.best_score_:.3f}")
print(f"vnořená CV: {vnorene.mean():.3f} ± {vnorene.std():.3f}")
best_score_ (optimistické): 0.922 vnořená CV: 0.921 ± 0.055
Máš 150 řádků a chceš vyladit model a zároveň poctivě odhadnout jeho kvalitu. Co je nejrozumnější?
U tak malých dat by jedna testovací množina dala velmi nejistý odhad. best_score_ je optimistické a skóre na trénovacích datech nic neříká.
Pod kapotou · ladění v praxi
- Rozsah volíš logaritmicky. Pro
alpha,Cnebo krok učení hledej přesscipy.stats.loguniform(1e-4, 1e2), rovnoměrné rozdělení by skoro všechny pokusy utratilo v horní dekádě. - Vítěz na okraji mřížky znamená, že mřížka je špatně. Rozšiř ji.
refitu více metrik musí dostat název metriky, podle které se má vybírat. Pomocí volatelného objektu můžeš rovnou implementovat pravidlo jedné standardní chyby.- Successive halving (
HalvingGridSearchCV, zatím experimentální, vyžadujefrom sklearn.experimental import enable_halving_search_cv) dá všem kandidátům málo zdrojů a slabé průběžně vyřazuje. - Bayesovská optimalizace (například Optuna a její TPE) volí další pokus podle předchozích. Vyplatí se, když je jeden trénink drahý. Vítězovu kletbu ale neruší, spíš ji zesiluje: čím víc pokusů, tím víc se přizpůsobuješ validačním datům.
- Opakované nahlížení na test je stejná chyba v pomalejším tempu. Každé rozhodnutí podle testu z něj dělá kus tréninku. Veřejné žebříčky soutěží tím trpí pravidelně.
Opakování
Vyzkoušej si: Jak se data dělí na části
Zvol počet částí a zamíchání a sleduj přiřazení. Ukáže se i příklad úniku dat.