Lidsky řečeno
Krejčí ti šije oblek. První vezme jen dvě míry a ušije pytel, který nesedí nikomu. Druhý změří úplně všechno, včetně boule od klíčů v kapse a toho, že ses zrovna nadechl. Oblek sedí dokonale, ale jen v téhle jedné vteřině. Vyndáš klíče, vydechneš a táhne to všude. Dobrý krejčí zachytí tvou postavu a obsah kapes ignoruje. Přesně tohle chceš od modelu.
Když model umí data nazpaměť
Každá naměřená data se skládají ze dvou částí:
- Signál je skutečná zákonitost, kterou chceš zachytit.
- Šum je náhoda: chyba měření, nálada zákazníka, počasí. Na nových datech bude jiný.
Model netuší, co je co. Dáš-li mu dost volnosti, naučí se i šum. Tomu se říká přeučení (overfitting). Opak, kdy je model moc jednoduchý a nezachytí ani signál, je podučení (underfitting).
Ukázka používá polynom, tedy křivku typu w0 + w1·x + w2·x² + .... Stupeň polynomu je nejvyšší mocnina a říká, jak moc se křivka smí vlnit. Tahej posuvníkem a sleduj dvě věci: jak křivka (tečky) prochází body (o) a co se děje s chybou. Chyba je tu průměr druhých mocnin odchylek, zkráceně MSE.
import numpy as np
rng = np.random.default_rng(7)
x = rng.uniform(-1, 1, 15)
y = np.sin(3 * x) + rng.normal(0, 0.25, 15)
x_test = rng.uniform(-1, 1, 500)
y_test = np.sin(3 * x_test) + rng.normal(0, 0.25, 500)
s = int(stupen)
w = np.linalg.lstsq(np.vander(x, s + 1), y, rcond=None)[0]
chyba_train = np.mean((np.vander(x, s + 1) @ w - y) ** 2)
chyba_test = np.mean((np.vander(x_test, s + 1) @ w - y_test) ** 2)
SIRKA, VYSKA = 49, 13
platno = [[" "] * SIRKA for _ in range(VYSKA)]
def nakresli(xs, ys, znak):
for a, b in zip(xs, ys):
radek = round((1.5 - b) / 3 * (VYSKA - 1))
sloupec = round((a + 1) / 2 * (SIRKA - 1))
if 0 <= radek < VYSKA:
platno[radek][sloupec] = znak
mrizka = np.linspace(-1, 1, SIRKA)
nakresli(mrizka, np.vander(mrizka, s + 1) @ w, ".")
nakresli(x, y, "o")
for radek in platno:
print("".join(radek).rstrip())
print(f"stupeň {s}: chyba na tréninku {chyba_train:.3f}, na testu {chyba_test:.3f}")
.....oo
.o. ..
.. o ..
.. oo
.o .
o oo .
. ..
.. .. .
. o.. .
... o.o.
...o o .
stupeň 3: chyba na tréninku 0.021, na testu 0.189Totéž jako tabulka. Trénovací chyba s rostoucím stupněm jen klesá. Testovací nejdřív klesá a pak vyletí nahoru.
import numpy as np
rng = np.random.default_rng(7)
x = rng.uniform(-1, 1, 15)
y = np.sin(3 * x) + rng.normal(0, 0.25, 15)
x_test = rng.uniform(-1, 1, 500)
y_test = np.sin(3 * x_test) + rng.normal(0, 0.25, 500)
print("stupeň trénink test")
for s in [0, 1, 3, 5, 7, 9, 12]:
w = np.linalg.lstsq(np.vander(x, s + 1), y, rcond=None)[0]
chyba_train = np.mean((np.vander(x, s + 1) @ w - y) ** 2)
chyba_test = np.mean((np.vander(x_test, s + 1) @ w - y_test) ** 2)
print(f"{s:>6} {chyba_train:7.3f} {chyba_test:9.2f}")
stupeň trénink test
0 0.755 0.67
1 0.293 0.28
3 0.021 0.19
5 0.019 0.12
7 0.017 0.43
9 0.017 1.31
12 0.007 31185.63Teď si tipni. Dáme modelu deset bodů, které jsou čistá náhoda, a polynom stupně 9, tedy deset nastavitelných čísel. Vyjde trénovací chyba prakticky nulová?
import numpy as np
rng = np.random.default_rng(0)
x = np.linspace(-1, 1, 10)
y = rng.normal(size=10)
X = np.vander(x, 10)
w = np.linalg.lstsq(X, y, rcond=None)[0]
chyba = np.mean((X @ w - y) ** 2)
print(chyba < 1e-9)
True
Deset rovnic o deseti neznámých má řešení, ať jsou čísla jakákoli. Model „vysvětlil“ dokonale něco, co žádné vysvětlení nemá. Nulová trénovací chyba tedy sama o sobě neříká vůbec nic.
chyba
│\ / test
│ \ /
│ \__ __/
│ ‾‾--__ __--‾‾
│\ ‾‾‾‾-----‾‾‾‾
│ ‾‾--__
│ ‾‾‾---______
│ ‾‾‾‾‾-------____ trénink
└────────────────────────────────────── složitost modelu
podučení ideál přeučeníPodučení, nebo přeučení?
Roztřiď příznaky podle toho, co modelu nejspíš je.
Automatická diagnóza
Napiš funkci diagnoza(chyba_train, chyba_test, cil). cil je chyba, kterou považuješ za přijatelnou. Funkce vrátí:
"podučení", když je už trénovací chyba větší nežcil,"přeučení", když je trénovací chyba v pořádku, ale testovací je větší nežcil,"v pořádku"jinak.
def diagnoza(chyba_train, chyba_test, cil):
return "v pořádku"
Bias a variance
Přeučení a podučení mají přesnější jména. Představ si, že stejný algoritmus trénuješ znovu a znovu, pokaždé na jiném vzorku dat ze stejného světa. Pak jsou to dvě různé vady:
- Bias (zkreslení): model se v průměru trefuje vedle. Je příliš jednoduchý, takže tvar reality prostě neumí.
- Variance (rozptyl): model se s každým vzorkem dat změní. V průměru možná sedí, ale každý jeden běh ustřelí jinam.
Lukostřelec to ukáže nejlépe. x jsou šípy, + je střed terče.
malý bias, malá variance velký bias, malá variance
. . . . . . . . . .
. . . x x .
. xx+x . . xxx .
. xx . . + .
. . . . . . . . . .
malý bias, velká variance velký bias, velká variance
. .x. . . . . x . .
. x x . . x x .
. + . . + x .
. x x . . x .
. . x . . . . . x .Pro čtvercovou chybu platí přesný rozklad. Očekávaná chyba na nových datech je součet tří kladných částí:
očekávaná chyba = bias² + variance + šumŠum neodstraníš žádným modelem, je to podlaha. Zbylé dvě části se obvykle přetahují: jednodušší model má větší bias a menší varianci, složitější naopak. Proto se mluví o kompromisu mezi bias a variance.
Není to jen teorie. V ukázce natrénujeme každý model na 300 různých vzorcích dat a všechny tři části přímo změříme. Protože si data generujeme sami, skutečnou křivku známe, což v praxi nikdy nenastane.
import numpy as np
SUM = 0.25
rng = np.random.default_rng(1)
mrizka = np.linspace(-0.8, 0.8, 41)
pravda = np.sin(3 * mrizka)
print("stupeň bias² variance šum² součet změřeno")
for s in [1, 3, 5, 7, 9]:
predikce = []
for _ in range(300):
x = rng.uniform(-1, 1, 30)
y = np.sin(3 * x) + rng.normal(0, SUM, 30)
w = np.linalg.lstsq(np.vander(x, s + 1), y, rcond=None)[0]
predikce.append(np.vander(mrizka, s + 1) @ w)
predikce = np.array(predikce)
bias2 = np.mean((predikce.mean(axis=0) - pravda) ** 2)
variance = np.mean(predikce.var(axis=0))
nova_y = pravda + rng.normal(0, SUM, predikce.shape)
zmereno = np.mean((predikce - nova_y) ** 2)
soucet = bias2 + variance + SUM**2
print(f"{s:>6} {bias2:8.4f} {variance:9.4f} {SUM**2:7.4f} {soucet:8.4f} {zmereno:8.4f}")
stupeň bias² variance šum² součet změřeno
1 0.1216 0.0140 0.0625 0.1981 0.2002
3 0.0022 0.0073 0.0625 0.0720 0.0713
5 0.0000 0.0115 0.0625 0.0740 0.0736
7 0.0001 0.0306 0.0625 0.0932 0.0942
9 0.0002 0.1906 0.0625 0.2533 0.2548Sleduj sloupce shora dolů. Přímka má obrovský bias, od stupně 3 je skoro nulový. Variance od stupně 3 naopak stále roste. Součet tří částí se téměř přesně shoduje s chybou změřenou přímo a nejmenší je u stupně 3, kde jsou bias i variance malé zároveň. Vyšší stupeň už nic nepřidá, jen víc kolísá.
Model má na tréninku i na testu podobnou, ale vysokou chybu. Co s největší pravděpodobností pomůže?
Podobná a vysoká chyba je známka velkého bias. Víc řádků průměruje varianci, ale model, který tvar dat neumí, se ho nenaučí ani z milionu řádků. Silnější regularizace by ho ještě víc omezila.
Pod kapotou · dvojitý sestup: U-křivka není celý příběh
Klasická U-křivka platí, dokud má model méně parametrů než dat. Za hranicí, kde počet parametrů p překročí počet vzorků n, může chyba zase klesat. Jde o double descent (Belkin a kol., 2019). Soustava má pak nekonečně mnoho přesných řešení a lstsq z nich vrací to s nejmenší normou. Tahle implicitní preference malých vah funguje jako skrytá regularizace. Vrchol chyby leží kolem p = n: matice je tam nejhůř podmíněná a přesné proložení existuje jediné, zato s obrovskými vahami. Tenhle jev pomáhá vysvětlit, proč přeparametrizované neuronové sítě často generalizují, i když umí trénovací data nazpaměť.
import numpy as np
n, D, SUM = 40, 200, 0.1
rng = np.random.default_rng(0)
print(" p medián chyby")
for p in [5, 10, 20, 30, 36, 40, 44, 50, 80, 120, 200]:
chyby = []
for _ in range(40):
pravda = rng.normal(size=D)
pravda /= np.linalg.norm(pravda)
X = rng.normal(size=(n, D))
y = X @ pravda + rng.normal(0, SUM, n)
w = np.zeros(D)
w[:p] = np.linalg.lstsq(X[:, :p], y, rcond=None)[0]
chyby.append(np.sum((w - pravda) ** 2) + SUM**2)
print(f"{p:>3} {np.median(chyby):10.3f}")
p medián chyby 5 1.106 10 1.217 20 1.699 30 3.457 36 6.670 40 61.370 44 6.812 50 3.596 80 1.411 120 0.994 200 0.822
V tabulce je vidět vrchol u p = 40 a to, že úplně vpravo je chyba nižší než u nejmenšího modelu vlevo. Příznaky jsou nezávislé se standardním normálním rozdělením, takže očekávanou testovací chybu dostaneš rovnou jako ‖ŵ − w‖² + σ² a testovací data nepotřebuješ. Rozklad bias a variance v téhle podobě platí jen pro čtvercovou chybu. U chyby 0/1 ve klasifikaci aditivní není a existuje několik nekompatibilních definic.
Co s tím: křivky učení
V praxi skutečnou křivku neznáš, takže bias a varianci přímo nezměříš. Máš ale křivku učení: jak se mění chyba na tréninku a na testu, když přidáváš data. Tady ji počítáme pro jednoduchý a pro složitý model. Bereme medián ze 40 pokusů, aby výsledek nekazily ojedinělé divoké běhy.
import numpy as np
rng = np.random.default_rng(2)
x_test = rng.uniform(-0.95, 0.95, 400)
y_test = np.sin(3 * x_test) + rng.normal(0, 0.25, 400)
def krivka(s, n):
chyby_train, chyby_test = [], []
for _ in range(40):
x = rng.uniform(-1, 1, n)
y = np.sin(3 * x) + rng.normal(0, 0.25, n)
w = np.linalg.lstsq(np.vander(x, s + 1), y, rcond=None)[0]
chyby_train.append(np.mean((np.vander(x, s + 1) @ w - y) ** 2))
chyby_test.append(np.mean((np.vander(x_test, s + 1) @ w - y_test) ** 2))
return np.median(chyby_train), np.median(chyby_test)
print(" stupeň 1 stupeň 9")
print(" n trénink test trénink test")
for n in [15, 30, 60, 120, 240, 480]:
a, b = krivka(1, n)
c, d = krivka(9, n)
print(f"{n:>4} {a:7.3f} {b:6.3f} {c:7.3f} {d:7.3f}")
stupeň 1 stupeň 9 n trénink test trénink test 15 0.195 0.235 0.019 3.617 30 0.205 0.216 0.037 0.090 60 0.222 0.209 0.052 0.075 120 0.214 0.205 0.052 0.067 240 0.224 0.205 0.059 0.064 480 0.231 0.204 0.061 0.064
Čti to takhle:
- Stupeň 1: obě chyby se rychle potkají a zůstanou vysoko. To je bias. Další data jsou vyhozené peníze.
- Stupeň 9: mezi tréninkem a testem zeje na začátku díra, která se s daty zavírá. To je variance. Tady další data pomáhají.
Proč vyhrál nejdivočejší model?
Kód má vybrat nejlepší stupeň polynomu. Pokaždé ale vybere ten nejvyšší.
Regularizace: pokuta za divokost
Podívej se znovu na přeučený polynom: aby se protáhl každým bodem, potřebuje obrovské váhy s opačnými znaménky. Regularizace přidá k chybě pokutu za velikost vah. Model pak musí vyvažovat dvě přání: sedět na data a zůstat klidný.
Nejběžnější varianta se jmenuje ridge nebo také L2 regularizace. Pokutou je součet druhých mocnin vah:
ridge: minimalizuj součet (predikce − y)² + λ · součet w²
řešení: w = (XᵀX + λ·I)⁻¹ XᵀyŘecké λ (lambda) je knoflík. Když je nulové, jde o obyčejnou regresi. Když je obrovské, váhy se stáhnou k nule a zbyde skoro rovná čára. Takovému číslu, které nastavuješ ty a model se ho sám neučí, se říká hyperparametr.
Stupeň polynomu necháme na 12, kde je model bez brzd úplně divoký. Tahej posuvníkem. Hodnota log_lam je mocnina desítky, takže -3 znamená λ = 0,001.
import numpy as np
rng = np.random.default_rng(7)
x = rng.uniform(-1, 1, 15)
y = np.sin(3 * x) + rng.normal(0, 0.25, 15)
x_test = rng.uniform(-1, 1, 500)
y_test = np.sin(3 * x_test) + rng.normal(0, 0.25, 500)
def priznaky(x):
return np.vander(x, 13, increasing=True)
def ridge(X, y, lam):
pokuta = np.eye(X.shape[1])
pokuta[0, 0] = 0 # absolutní člen nepokutujeme
return np.linalg.solve(X.T @ X + lam * pokuta, X.T @ y)
lam = 10.0 ** log_lam
w = ridge(priznaky(x), y, lam)
SIRKA, VYSKA = 49, 13
platno = [[" "] * SIRKA for _ in range(VYSKA)]
def nakresli(xs, ys, znak):
for a, b in zip(xs, ys):
radek = round((1.5 - b) / 3 * (VYSKA - 1))
sloupec = round((a + 1) / 2 * (SIRKA - 1))
if 0 <= radek < VYSKA:
platno[radek][sloupec] = znak
mrizka = np.linspace(-1, 1, SIRKA)
nakresli(mrizka, priznaky(mrizka) @ w, ".")
nakresli(x, y, "o")
for radek in platno:
print("".join(radek).rstrip())
chyba_train = np.mean((priznaky(x) @ w - y) ** 2)
chyba_test = np.mean((priznaky(x_test) @ w - y_test) ** 2)
print(f"λ = {lam:g}: trénink {chyba_train:.3f}, test {chyba_test:.3f}, největší váha {np.abs(w).max():.1f}")
.
......oo
.o .. .
.. o .. .
.. oo.
.o
o oo
. .
. ..
. o..
.. o.o.
.....o.o
λ = 0.001: trénink 0.018, test 0.208, největší váha 3.9Celý průběh v jedné tabulce. Trénovací chyba s rostoucím λ jen roste, to je cena za klid. Testovací je špatná na obou koncích a nejlepší hodnoty má uprostřed.
import numpy as np
rng = np.random.default_rng(7)
x = rng.uniform(-1, 1, 15)
y = np.sin(3 * x) + rng.normal(0, 0.25, 15)
x_test = rng.uniform(-1, 1, 500)
y_test = np.sin(3 * x_test) + rng.normal(0, 0.25, 500)
X = np.vander(x, 13, increasing=True)
X_test = np.vander(x_test, 13, increasing=True)
pokuta = np.eye(13)
pokuta[0, 0] = 0
print(" λ trénink test největší váha")
for lam in [1e-6, 1e-4, 1e-2, 1e-1, 1, 10, 100]:
w = np.linalg.solve(X.T @ X + lam * pokuta, X.T @ y)
chyba_train = np.mean((X @ w - y) ** 2)
chyba_test = np.mean((X_test @ w - y_test) ** 2)
print(f"{lam:>8g} {chyba_train:7.3f} {chyba_test:8.3f} {np.abs(w).max():13.2f}")
λ trénink test největší váha
1e-06 0.017 2.091 13.76
0.0001 0.017 0.719 3.75
0.01 0.023 0.237 2.87
0.1 0.038 0.276 2.27
1 0.179 0.226 1.27
10 0.496 0.436 0.38
100 0.712 0.626 0.20Ridge vlastníma rukama
Napiš funkci ridge(X, y, lam), která vrátí váhy w podle vzorce w = (XᵀX + λ·I)⁻¹ Xᵀy. Data jsou vycentrovaná, takže absolutní člen neřeš a pokutuj všechny váhy. Inverzní matici nepočítej, použij np.linalg.solve.
import numpy as np
def ridge(X, y, lam):
return np.zeros(X.shape[1])
L1: pokuta, která umí nulovat
Druhá slavná pokuta je L1, regresi s ní se říká lasso. Místo druhých mocnin sčítá absolutní hodnoty vah.
lasso: minimalizuj (1 / 2n) · součet (predikce − y)² + λ · součet |w|Rozdíl vypadá nevinně, ale chování je jiné. L2 váhy zmenšuje poměrem, takže se k nule blíží a nikdy ji nedosáhne. L1 z nich odečítá stálou částku, takže malé váhy skončí přesně na nule. Lasso tak samo vybírá příznaky.
Jádrem je operace měkký práh (soft thresholding): zmenši absolutní hodnotu o t, a když by vyšla záporná, dej nulu.
měkký_práh(w, t) = znaménko(w) · max(|w| − t, 0)Měkký práh
Napiš funkci mekky_prah(w, t), která pracuje s polem NumPy a vrátí nové pole podle vzorce výše. Například pro [3.0, -0.5, -2.0] a t = 1 vrátí [2.0, 0.0, -1.0].
import numpy as np
def mekky_prah(w, t):
return w
Stačí střídat krok gradientního sestupu a měkký práh, a máš funkční lasso. Metoda se jmenuje ISTA. Z osmi příznaků mají vliv jen tři. Porovnej, co s tím udělá ridge a co lasso.
import numpy as np
rng = np.random.default_rng(0)
n = 100
pravda = np.array([3.0, 0, -2.0, 0, 0, 1.5, 0, 0])
X = rng.normal(size=(n, 8))
y = X @ pravda + rng.normal(0, 0.5, n)
lam = 0.2
def mekky_prah(w, t):
return np.sign(w) * np.maximum(np.abs(w) - t, 0)
krok = 1 / np.linalg.eigvalsh(X.T @ X / n).max()
lasso = np.zeros(8)
for _ in range(1000):
gradient = X.T @ (X @ lasso - y) / n
lasso = mekky_prah(lasso - krok * gradient, krok * lam)
ridge = np.linalg.solve(X.T @ X / n + lam * np.eye(8), X.T @ y / n)
print("pravda ridge lasso")
for p, r, l in zip(pravda, ridge, lasso):
print(f"{p:6.2f} {r:6.2f} {l + 0.0:6.2f}")
pravda ridge lasso 3.00 2.33 2.68 0.00 -0.01 0.00 -2.00 -1.56 -1.74 0.00 -0.08 0.00 0.00 -0.05 0.00 1.50 1.28 1.35 0.00 -0.03 0.00 0.00 -0.07 0.00
Ridge nechá všech osm vah nenulových, i když jsou některé maličké. Lasso ty zbytečné přesně vynuluje a za to trochu zkrátí i ty užitečné.
Ve scikit-learn jsou obě metody hotové a síla pokuty se tu jmenuje alpha. Dataset load_diabetes má příznaky už předem naškálované. Hledej dvě věci: počet nulových vah u lassa s rostoucí alpha stoupá, zatímco u ridge zůstává nulový. A skóre R² (1 je dokonalost) má u obou někde své optimum.
from sklearn.datasets import load_diabetes
from sklearn.linear_model import Lasso, Ridge
from sklearn.model_selection import train_test_split
X, y = load_diabetes(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=0)
print(" alpha ridge R² nuly lasso R² nuly")
for alpha in [0.001, 0.01, 0.1, 1.0, 10.0]:
r = Ridge(alpha=alpha, random_state=0).fit(X_tr, y_tr)
l = Lasso(alpha=alpha, random_state=0, max_iter=10000).fit(X_tr, y_tr)
print(f"{alpha:>6} {r.score(X_te, y_te):9.3f} {(r.coef_ == 0).sum():>4}"
f" {l.score(X_te, y_te):9.3f} {(l.coef_ == 0).sum():>4}")
alpha ridge R² nuly lasso R² nuly 0.001 0.392 0 0.392 0 0.01 0.391 0 0.388 1 0.1 0.402 0 0.388 3 1.0 0.365 0 0.306 8 10.0 0.137 0 -0.000 10
Máš 500 příznaků a tušíš, že jich je užitečných jen pár. Chceš model, který ti rovnou řekne které. Co zvolíš?
L1 pokuta vede k řídkému řešení. Ridge váhy jen zmenšuje, takže bys pořád měl všech 500 nenulových.
Pod kapotou · ridge přes SVD, efektivní počet parametrů a pasti v API
Se singulárním rozkladem X = U·diag(d)·Vᵀ má ridge tvar w = V·diag(d / (d² + λ))·Uᵀy. Každý směr dat se tedy utlumí faktorem d² / (d² + λ): silné směry zůstanou, slabé, kde se šum nejvíc nafukuje, zmizí. Součet těchto faktorů je efektivní počet parametrů a dává smysl i pro neceločíselné hodnoty.
import numpy as np
x = np.linspace(-1, 1, 15)
X = np.vander(x, 13, increasing=True)[:, 1:]
X = X - X.mean(axis=0)
d = np.linalg.svd(X, compute_uv=False)
print(f"číslo podmíněnosti X: {d[0] / d[-1]:.0f}")
for lam in [0, 1e-4, 1e-2, 1, 100]:
print(f"λ = {lam:<7g} efektivně parametrů: {np.sum(d**2 / (d**2 + lam)):5.2f}")
číslo podmíněnosti X: 40440 λ = 0 efektivně parametrů: 12.00 λ = 0.0001 efektivně parametrů: 8.01 λ = 0.01 efektivně parametrů: 5.76 λ = 1 efektivně parametrů: 2.92 λ = 100 efektivně parametrů: 0.25
Co v dokumentaci snadno přehlédneš:
Ridgeminimalizuje‖y − Xw‖² + α‖w‖², aleLasso(1/2n)‖y − Xw‖² + α‖w‖₁. Stejnéalphatedy u obou znamená úplně jinou sílu a závislost nanje také jiná.LogisticRegressionje regularizovaná ve výchozím nastavení (L2,C=1.0) aCje převrácená hodnota síly: menšíCznamená silnější pokutu. Koeficienty proto bez standardizace závisí na jednotkách, což je oblíbený zdroj špatných interpretací.XᵀXčtvercem zhoršuje číslo podmíněnosti, proto seriózní řešiče pracují s rozklademX(QR, SVD) nebo iterativně.- Ridge odpovídá odhadu MAP s normálním apriorním rozdělením vah, lasso s Laplaceovým.
- Mezi silně korelovanými příznaky si lasso vybírá dost libovolně a výběr je nestabilní.
ElasticNetkombinuje L1 a L2 a tenhle problém zmírňuje. - Předčasné zastavení gradientního sestupu se u lineární regrese chová podobně jako ridge: slabé směry dat se za omezený počet kroků nestihnou naučit.
Regularizace není jen vzorec
Regularizace je cokoli, co modelu záměrně bere volnost. U stromů to je omezení hloubky nebo minimální velikost listu, u boostingu malý krok učení a předčasné zastavení. Neuronové sítě přidávají ještě další triky, k nim se dostaneš později.
Tady strom na datech o nádorech prsu. Sleduj rozdíl mezi přesností na tréninku a na testu: bez omezení hloubky je trénink dokonalý, test ale dokonalý není. Podívej se, při jaké hloubce je test nejlepší a jestli další hloubka ještě něco přináší.
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import 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.3, random_state=0, stratify=y)
print("hloubka listů trénink test")
for hloubka in [1, 2, 3, 4, 6, 8, None]:
strom = DecisionTreeClassifier(max_depth=hloubka, random_state=0).fit(X_tr, y_tr)
print(f"{str(hloubka):>7} {strom.get_n_leaves():>5} {strom.score(X_tr, y_tr):7.3f} {strom.score(X_te, y_te):5.3f}")
hloubka listů trénink test
1 2 0.932 0.889
2 4 0.942 0.906
3 8 0.980 0.901
4 12 0.990 0.906
6 16 1.000 0.906
8 16 1.000 0.906
None 16 1.000 0.906Která brzda patří ke kterému modelu?
Spoj model s parametrem, kterým ho regularizuješ.
Opakování
Vyzkoušej si: Přeučení na polynomech
Zvyšuj stupeň polynomu a šum a sleduj trénovací a testovací chybu. Od určité chvíle se rozejdou.