0 dní v řadě · 0 bodů

Strojové učení · 35 min

Křížová validace a ladění

Jak spolehlivě změřit kvalitu modelu, vybrat hyperparametry a nenaletět na výsledek, který vypadá lépe, než ve skutečnosti je.

Hloubka
Úkoly
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}")
Výstup
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:

  1. Data náhodně rozděl na k stejně velkých dílů. Dílu se říká fold.
  2. Jeden díl odlož na ověření, na zbytku natrénuj nový model a změř ho.
  3. Opakuj tak, aby si každý díl jednou zahrál ověřovací.
  4. Výsledky zprůměruj.
text
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])
Výstup
[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}")
Výstup
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.

Úkol

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

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)
Výstup
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())
Výstup
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]
Roztřiď

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}")
Výstup
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))
Výstup
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)
Výstup
       λ    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.01

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

Úkol

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

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

Úkol

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

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

Doplň 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}")
Výstup
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}")
Výstup
{'max_depth': 6.0, 'max_features': 0.875, 'min_samples_leaf': 4.0}
skóre z CV 0.939, na testu 0.944
Kvíz

Spustil jsi GridSearchCV na 40 kombinacích. Proč best_score_ obvykle trochu přeceňuje skutečnou kvalitu?

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}")
Výstup
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ěří.
text
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}")
Výstup
best_score_ (optimistické): 0.922
vnořená CV:                 0.921 ± 0.055
Kvíz

Máš 150 řádků a chceš vyladit model a zároveň poctivě odhadnout jeho kvalitu. Co je nejrozumnější?

Pod kapotou · ladění v praxi
  • Rozsah volíš logaritmicky. Pro alpha, C nebo krok učení hledej přes scipy.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.
  • refit u 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žaduje from 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ě.
Kartičky

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.