0 dní v řadě · 0 bodů

Strojové učení · 35 min

Přeučení, bias a variance, regularizace

Proč model, který umí data nazpaměť, selhává na nových. Naučíš se přeučení rozpoznat, změřit a zkrotit regularizací.

Hloubka
Úkoly
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}")
Výstup
                                .....oo
                             .o.       ..
                           ..          o ..
                         ..               oo
                       .o                   .
o                    oo                      .
 .                  ..
  ..              ..                          .
    .          o..                             .
     ...    o.o.
        ...o o                                  .
stupeň 3: chyba na tréninku 0.021, na testu 0.189

Totéž 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}")
Výstup
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.63

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

text
chyba
  │\                                  /   test
  │ \                               /
  │  \__                         __/
  │     ‾‾--__             __--‾‾
  │\          ‾‾‾‾-----‾‾‾‾
  │  ‾‾--__
  │        ‾‾‾---______
  │                    ‾‾‾‾‾-------____   trénink
  └──────────────────────────────────────  složitost modelu
     podučení        ideál       přeučení
Roztřiď

Podučení, nebo přeučení?

Roztřiď příznaky podle toho, co modelu nejspíš je.

Úkol

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

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.

text
  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í:

text
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}")
Výstup
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.2548

Sleduj 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á.

Kvíz

Model má na tréninku i na testu podobnou, ale vysokou chybu. Co s největší pravděpodobností pomůže?

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}")
Výstup
  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}")
Výstup
         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í.
Najdi chybu

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:

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

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

Celý 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}")
Výstup
       λ  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.20
Úkol

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

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.

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

text
měkký_práh(w, t) = znaménko(w) · max(|w| − t, 0)
Úkol

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

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}")
Výstup
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}")
Výstup
 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
Kvíz

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íš?

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}")
Výstup
čí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š:

  • Ridge minimalizuje ‖y − Xw‖² + α‖w‖², ale Lasso (1/2n)‖y − Xw‖² + α‖w‖₁. Stejné alpha tedy u obou znamená úplně jinou sílu a závislost na n je také jiná.
  • LogisticRegression je regularizovaná ve výchozím nastavení (L2, C=1.0) a C je převrácená hodnota síly: menší C znamená 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 rozkladem X (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í. ElasticNet kombinuje 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}")
Výstup
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.906
Spoj dvojice

Která brzda patří ke kterému modelu?

Spoj model s parametrem, kterým ho regularizuješ.

Kartičky

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.