Skip to content

← Späť

POK-ISI Lab 3

Files

Cvičenie 3 - Regularizácia a generalizácia modelov

  1. Príprava prostredia
  2. O čom je cvičenie
  3. Ciele
  4. Teoretické minimum
  5. Postup
    1. Krok 1: Demonštrácia a diagnostika pretrénovania
      1. Úloha 1.1 - Vplyv zložitosti modelu na pretrénovanie
    2. Krok 2: Porovnanie regularizačných metód Ridge, Lasso a Elastic Net
      1. Úloha 2.1 - Porovnanie vplyvu regularizácie na chybu modelu
      2. Úloha 2.2 - Vplyv regularizácie na koeficienty modelu
    3. Krok 3: Regularizačná cesta a stabilita výberu korelovaných príznakov
      1. Úloha 3.1 - Regularizačná cesta modelu Lasso
      2. Úloha 3.2 - Stabilita výberu pri korelovaných príznakoch
    4. Krok 4: Výber sily regularizácie pomocou krížovej validácie
      1. Úloha 4.1 - Validačná krivka
    5. Krok 5: Záverečné vyhodnotenie modelu
      1. Úloha 5.1 - Jednorazové vyhodnotenie na testovacej množine
  6. Doplňujúce úlohy (bonus)
  7. Doplňujúce zdroje

Týždeň: 3 | Predpoklady:numpy, pandas, matplotlib, scikit-learn, validácia modelov, únik dát

Príprava prostredia Anchor

V aktivovanom virtuálnom prostredí spustite nasledujúci príkaz:

Zdrojový kód

pip install numpy pandas matplotlib "scikit-learn>=1.4"

O čom je cvičenie Anchor

Nízka chyba na trénovacích dátach sama osebe nezaručuje, že model bude dobre predikovať aj na nových dátach. Model sa totiž môže prispôsobiť nielen skutočným vzťahom v dátach, ale aj šumu a náhodným osobitostiam trénovacej vzorky. Regularizácia obmedzuje efektívnu zložitosť modelu a môže zlepšiť jeho schopnosť zovšeobecňovať na nové dáta, spravidla za cenu horšieho prispôsobenia trénovacím dátam. Predstavuje tak jeden z hlavných nástrojov na riadenie kompromisu medzi vychýlením a rozptylom ( bias-variance trade-off). Príliš slabá regularizácia môže ponechať model pretrénovaný, zatiaľ čo príliš silná môže viesť k podtrénovaniu.

Cvičenie sa zameriava na rozpoznanie pretrénovania a na jeho obmedzenie pomocou regularizácie. Porovnáte regularizáciu s L1 penalizáciou, L2 penalizáciou a ich kombináciou, preskúmate ich vplyv na koeficienty modelu a vhodnú silu regularizácie zvolíte pomocou krížovej validácie. Porovnaním trénovacej a validačnej chyby pri rôznych hodnotách sily regularizácie sa naučíte rozpoznávať prejavy pretrénovania a podtrénovania a lepšie porozumiete kompromisu medzi vychýlením a rozptylom.

Ciele Anchor

  1. Rozpoznať prejavy pretrénovania a podtrénovania modelov na základe porovnania trénovacej a validačnej chyby.
  2. Vysvetliť rozdiely medzi L1 penalizáciou, L2 penalizáciou a ich kombináciou a opísať ich vplyv na koeficienty modelu.
  3. Pomocou krížovej validácie zvoliť vhodné hyperparametre regularizácie a vyhodnotiť validačnú výkonnosť modelu.
  4. Interpretovať regularizačnú cestu a vysvetliť vplyv jednotlivých penalizácií na koeficienty korelovaných príznakov.
  5. Posúdiť generalizačnú schopnosť zvoleného modelu na nezávislých testovacích dátach a porovnať výsledky s odhadom získaným krížovou validáciou.

Dátová sada

Na tomto cvičení budeme pracovať s dátovou sadou Diabetes, ktorá obsahuje 442 pozorovaní a 10 numerických príznakov, napríklad vek, index telesnej hmotnosti, krvný tlak a vybrané hodnoty z krvných testov. Cieľovou premennou je číselný ukazovateľ progresie ochorenia po jednom roku, preto ide o regresnú úlohu.

Vzhľadom na pomerne malý počet pozorovaní je táto dátová sada v spojení s dostatočne zložitým modelom vhodná na názornú ukážku pretrénovania. Pomocou polynomického rozšírenia vytvoríme mocniny a súčiny pôvodných príznakov, čím zvýšime počet vstupných príznakov a flexibilitu modelu. Model sa tak môže výraznejšie prispôsobiť aj šumu a náhodným osobitostiam trénovacích dát. Následne budeme sledovať, ako regularizácia obmedzuje jeho efektívnu zložitosť a za akých podmienok zlepšuje schopnosť zovšeobecňovať na nové dáta.

Funkcia load_diabetes vracia príznaky už centrované a škálované na celej dátovej sade (predvolené scaled=True). Pri vlastných dátach sa škálovanie učí iba z trénovacích dát, preto je StandardScaler súčasťou každej Pipeline aj v tomto cvičení.

Dátová sada slúži ako didaktický príklad na demonštráciu princípov strojového učenia. Vytvorený model preto nie je určený na klinické rozhodovanie ani na predikciu zdravotného stavu konkrétnych pacientov.

Zdrojový kód

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split

RANDOM_STATE = 42

# load the Diabetes dataset
data = load_diabetes(as_frame=True)
X, y = data.data, data.target

# split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=RANDOM_STATE)

print(f"Training set: {X_train.shape}")
print(f"Test set: {X_test.shape}")
print(X_train.describe().T[["mean", "std", "min", "max"]].round(3))

Teoretické minimum Anchor

V tomto cvičení používame regularizáciu, ktorá do účelovej funkcie pridáva k trénovacej chybe penalizáciu veľkosti koeficientov modelu. Pri učení preto hľadáme kompromis medzi prispôsobením trénovacím dátam a obmedzením veľkosti koeficientov. Cieľom je zlepšiť predikcie na nových dátach - zlepšenie však nie je zaručené a overujeme ho pomocou validácie.

Lasso (L1 regularizácia) - penalizuje súčet absolútnych hodnôt koeficientov. Niektoré koeficienty môže nastaviť presne na nulu, čím vytvára riedky model a vykonáva výber príznakov. Pri silne korelovaných vstupoch môže výber závisieť od konkrétnej trénovacej vzorky. Nulový koeficient preto nie je dôkazom vecnej nedôležitosti premennej. Pri polynomickom rozšírení sa výber týka jednotlivých členov - pôvodných príznakov, ich mocnín a interakcií - nie automaticky celých pôvodných premenných.

Ridge (L2 regularizácia) - penalizuje súčet štvorcov koeficientov. Zmenšuje ich celkovú L2 normu, spravidla ich však nenastavuje presne na nulu, takže nevykonáva výber príznakov. Pomáha stabilizovať odhady najmä pri silne korelovaných vstupoch a má tendenciu rozdeliť ich príspevok medzi viaceré koeficienty. Neznamená to, že každý jednotlivý koeficient musí s rastúcou hodnotou hyperparametra alpha monotónne klesať v absolútnej hodnote.

Elastic Net (kombinácia L1 a L2) - spája možnosť nulovania koeficientov s ich stabilizáciou. Pri silne korelovaných príznakoch má väčšiu tendenciu ponechať skupinu súvisiacich príznakov spoločne než samotné Lasso. V implementácii scikit-learn hyperparameter alpha určuje celkovú silu penalizácie a hyperparameter l1_ratio pomer jej L1 a L2 zložky. Hodnoty bližšie k 1 zdôrazňujú L1 penalizáciu, hodnoty bližšie k 0 zasa L2 penalizáciu. Pri l1_ratio=1 dostávame Lasso, pri l1_ratio=0 zostáva iba L2 penalizácia. Na samotnú L2 regularizáciu v cvičení používame Ridge.

Výber sily regularizácie - väčšie alpha znamená silnejšiu penalizáciu v rámci danej metódy a pri nezmenených ostatných nastaveniach. Príliš slabá regularizácia nemusí potlačiť pretrénovanie, naopak príliš silná regularizácia môže viesť k podtrénovaniu. Vhodnú hodnotu vyberáme podľa validačnej chyby pomocou krížovej validácie. Pri Elastic Net môžeme rovnakým spôsobom vyberať aj hyperparameter l1_ratio. Rovnaké číselné alpha pri rôznych metódach neznamená rovnako silnú penalizáciu, pretože sa líši tvar penalizácie aj škálovanie jednotlivých členov účelovej funkcie.

Poznámka

Penalizácia pôsobí priamo na veľkosť koeficientov. Ak majú vstupy rozdielne jednotky, rovnaká zmena predikcie môže vyžadovať veľmi odlišné koeficienty. Bez škálovania teda penalizácia závisí aj od voľby jednotiek. StandardScaler preto patrí do tej istej Pipeline ako model.

Postup Anchor

Krok 1: Demonštrácia a diagnostika pretrénovania Anchor

Samotná vysoká chyba natrénovaného modelu ešte neznamená pretrénovanie. Typickým prejavom pretrénovania je výrazná generalizačná medzera - model dosahuje nízku chybu na trénovacích dátach, ale podstatne vyššiu chybu na validačných dátach.

Zložitosť modelu budeme zvyšovať polynomickým rozšírením príznakov. S rastúcim stupňom pribúdajú mocniny a interakcie pôvodných príznakov, čím rastie počet koeficientov lineárnej regresie a zároveň aj samotná flexibilita modelu. Pre každý stupeň porovnáme trénovaciu a validačnú chybu neregularizovaného modelu a budeme sledovať, ako sa mení generalizačná medzera.

Úloha 1.1 - Vplyv zložitosti modelu na pretrénovanie Anchor

Preskúmajte, ako stupeň polynómu ovplyvňuje trénovaciu a validačnú chybu. Pre každú hodnotu hyperparametra degree zo zoznamu [1, 2, 3] skonštruujte Pipeline s krokmi PolynomialFeatures, StandardScaler a LinearRegression. Pri polynomickom rozšírení nastavte include_bias=False.

Modely vyhodnoťte pomocou päťnásobnej krížovej validácie s rovnakými foldmi, a to iba na trénovacej množine, konkrétne X_train, y_train. Testovaciu množinu ponechajte na záverečné vyhodnotenie zvoleného modelu. Použite cross_validate(..., scoring="neg_root_mean_squared_error", return_train_score=True). Vrátené skóre má opačné znamienko než štandardná hodnota metriky RMSE, preto pred interpretáciou výsledkov zmeňte jeho znamienko. Pre každý stupeň vypočítajte priemer trénovacích a validačných hodnôt metriky RMSE cez päť foldov.

Doplňte časti kódu označené komentárom TODO v kostre nižšie.

Zdrojový kód

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import KFold, cross_validate
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler

cv = KFold(n_splits=5, shuffle=True, random_state=RANDOM_STATE)
rows = []

for degree in [1, 2, 3]:
    # TODO 1: create a pipeline with the steps "poly", "scaler" and "reg"
    model = ...

    # TODO 2: use cross_validate to compute the RMSE score for the training and validation sets
    scores = ...

    # convert negative scores to RMSE
    train_rmse = -scores["train_score"].mean()
    validation_rmse = -scores["test_score"].mean()
    # count the generated polynomial features
    n_features = model.named_steps["poly"].fit_transform(X_train).shape[1]

    rows.append({
        "degree": degree,
        "n_features": n_features,
        "train_RMSE": train_rmse,
        "validation_RMSE": validation_rmse,
    })

overfit_results = pd.DataFrame(rows)

overfit_results["generalization_gap"] = (overfit_results["validation_RMSE"] - overfit_results["train_RMSE"])
print(overfit_results.round(2))

# plot RMSE score by polynomial degree
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(overfit_results["degree"], overfit_results["train_RMSE"], marker="o", label="Training RMSE")
ax.plot(overfit_results["degree"], overfit_results["validation_RMSE"], marker="s", label="Validation RMSE")

# log scale makes large differences in RMSE easier to compare
ax.set_yscale("log")

ax.set_xticks(overfit_results["degree"])
ax.set_xlabel("Polynomial degree")
ax.set_ylabel("RMSE (log scale)")
ax.set_title("Training and validation error by model complexity")
ax.legend()

plt.tight_layout()
plt.show()

Na základe výsledkov posúďte, či zvýšenie stupňa polynómu zlepšuje generalizačnú schopnosť modelu, alebo vykazuje prejavy pretrénovania. Sledujte najmä situáciu, keď trénovacia chyba klesá, ale validačná chyba rastie.

Upozornenie

Najnižšia trénovacia chyba nezaručuje najlepšiu generalizáciu. Zložitejší model sa môže prispôsobiť aj šumu v trénovacích dátach a na nových pozorovaniach dosahovať horšie výsledky. Model preto vyberajte podľa validačnej chyby, trénovaciu chybu používajte spolu s validačnou na diagnostiku pretrénovania.

Dokumentácia: Pipeline, PolynomialFeatures, StandardScaler, cross_validate

Krok 2: Porovnanie regularizačných metód Ridge, Lasso a Elastic Net Anchor

V predchádzajúcom kroku sme pozorovali, že zvýšenie zložitosti modelu môže znížiť trénovaciu chybu, ale zároveň zhoršiť generalizáciu. Pri učení lineárnej regresie model každému príznaku priradí koeficient, teda váhu určujúcu jeho príspevok k predikcii. V našom prípade majú vlastné váhy aj vytvorené mocniny a interakcie príznakov. Teraz preskúmame, ako regularizácia obmedzuje veľkosť týchto váh a môže tým zmierniť pretrénovanie.

Ridge regresia (L2) zmenšuje veľkosť koeficientov bez toho, aby ich spravidla vynulovala. Pri korelovaných príznakoch má tendenciu rozdeľovať ich príspevok k predikcii medzi viaceré koeficienty. Lasso regresia (L1) môže niektoré koeficienty nastaviť presne na nulu, čím vykonáva implicitný výber príznakov. Pri silne korelovaných vstupoch však môže malá zmena dát viesť k výberu iného príznaku. Elastic Net kombinuje L1 a L2 penalizáciu, čo umožňuje vytvoriť riedky model, teda model s časťou nulových koeficientov, a zároveň môže zvýšiť stabilitu pri korelovaných vstupoch.

Pri rovnakom polynomickom rozšírení porovnáme, ako tieto metódy ovplyvňujú validačnú chybu, veľkosť koeficientov a počet nenulových členov modelu.

Úloha 2.1 - Porovnanie vplyvu regularizácie na chybu modelu Anchor

Preskúmajte, ako regularizácia ovplyvňuje trénovaciu a validačnú chybu modelu. Porovnajte lineárnu regresiu bez regularizácie (OLS) s metódami Ridge, Lasso a Elastic Net. Vo všetkých prípadoch nastavte v kroku PolynomialFeatures hyperparameter degree=2 a použite rovnaký postup polynomického rozšírenia a štandardizácie v rámci Pipeline. Krížovú validáciu vykonajte iba na trénovacej množine, konkrétne X_train, y_train, s rovnakým rozdelením do piatich foldov ako v Kroku 1.

Použite tieto pevne zvolené hodnoty hyperparametrov: Ridge(alpha=10.0), Lasso(alpha=1.0) a ElasticNet(alpha=1.0, l1_ratio=0.5). Hyperparameter alpha určuje silu regularizácie. Pri metóde Elastic Net hyperparameter l1_ratio navyše určuje pomer L1 a L2 zložky penalizácie.

Pre jednotlivé modely vypočítajte a porovnajte priemernú trénovaciu a validačnú hodnotu metriky RMSE cez päť foldov. Variabilitu validačnej chyby vyjadrite smerodajnou odchýlkou validačných hodnôt RMSE medzi foldmi. Posúďte, ako sa oproti neregularizovanému modelu zmenila validačná chyba a rozdiel medzi trénovacou a validačnou chybou. Vplyv regularizácie na koeficienty preskúmate v Úlohe 2.2.

Výsledky interpretujte ako demonštráciu účinku regularizácie pri konkrétnych nastaveniach. Hodnoty hyperparametrov zatiaľ neboli ladené, preto z porovnania nemožno vyvodiť všeobecné poradie kvality metód. Rovnaká číselná hodnota hyperparametra alpha navyše nepredstavuje pri rôznych metódach ekvivalentnú penalizáciu.

Doplňte časti kódu označené komentárom TODO v kostre nižšie.

Zdrojový kód

from sklearn.linear_model import ElasticNet, Lasso, Ridge

# fixed (untuned) hyperparameters to demonstrate the effect of regularization
models = {
    "OLS": LinearRegression(),
    # TODO 1: add "Ridge", "Lasso" and "Elastic Net" with the hyperparameters from the assignment;
    #         set max_iter=50_000 for Lasso and Elastic Net so that coordinate descent converges
}

rows = []
fitted_models = {}

# apply the same feature expansion and scaling to each model
for name, regressor in models.items():
    # TODO 2: pipeline with the steps "poly" (degree=2, include_bias=False), "scaler" and "reg" (= regressor)
    pipe = ...

    # TODO 3: 5-fold CV on the same folds cv as in Task 1.1 (RMSE, including the training scores)
    scores = ...

    # fit on the whole training set - Task 2.2 inspects the coefficients
    pipe.fit(X_train, y_train)
    fitted_models[name] = pipe

    # convert negative scores to RMSE and summarize fold results
    rows.append({
        "model": name,
        "train_RMSE": -scores["train_score"].mean(),
        "validation_RMSE": -scores["test_score"].mean(),
        "validation_SD": (-scores["test_score"]).std(ddof=1),
    })

# sort by validation RMSE
comparison = pd.DataFrame(rows).sort_values("validation_RMSE")
print(comparison.round(2))

Poznámka

Nižšia priemerná validačná RMSE sama osebe nepreukazuje lepšiu generalizačnú schopnosť modelu. Pri interpretácii zohľadnite aj variabilitu výsledkov medzi foldmi, vyjadrenú smerodajnou odchýlkou. Tá však nie je intervalom spoľahlivosti ani kritériom štatistickej významnosti. Keďže modely vyhodnocujeme na rovnakých rozdeleniach dát, podrobnejšie porovnanie má vychádzať z párových rozdielov hodnôt metriky RMSE na jednotlivých foldoch. Závery sa vzťahujú na použité konfigurácie, nie na všeobecnú prevahu jednej regularizačnej metódy.

Dokumentácia: Ridge, Lasso, ElasticNet, cross_validate

Úloha 2.2 - Vplyv regularizácie na koeficienty modelu Anchor

Preskúmajte, ako jednotlivé regularizačné metódy ovplyvňujú koeficienty modelu v porovnaní s neregularizovanou lineárnou regresiou. Z modelov uložených v premennej fitted_models získajte koeficienty a priraďte k nim názvy zodpovedajúcich polynomických príznakov. Všetky modely musia byť natrénované na rovnakej trénovacej množine X_train, y_train s rovnakým polynomickým rozšírením a rovnakou štandardizáciou.

Pre jednotlivé modely porovnajte:

  • L2 normu vektora koeficientov,
  • najväčšiu absolútnu hodnotu koeficientu,
  • počet koeficientov považovaných za numericky nulové podľa podmienky abs(coef) <= 1e-10.

Do týchto výpočtov nezahŕňajte absolútny člen ( intercept). Koeficienty interpretujte vzhľadom na štandardizované polynomické príznaky. Niektoré polynomické členy sú redundantné (napr. druhá mocnina dvojhodnotového príznaku sex), preto jednotlivé koeficienty neregularizovaného modelu interpretujte opatrne.

Kód zároveň pre každý model vykreslí 15 koeficientov s najväčšou absolútnou hodnotou a farebne odlíši kladné a záporné hodnoty. Doplňte časti kódu označené komentárom TODO v kostre nižšie.

Pomocou vypočítaných charakteristík a grafov porovnajte, ako jednotlivé metódy ovplyvnili veľkosť koeficientov. Pri metódach Lasso a Elastic Net posúďte aj to, či pri zvolených nastaveniach vznikol riedky model. Nulovanie vyhodnoťte podľa počtu numericky nulových koeficientov, pretože graf najväčších koeficientov ho nemusí zachytiť.

Zdrojový kód

from matplotlib.patches import Patch

coef_summary = []

for name, pipe in fitted_models.items():
    # TODO 1: names of the polynomial features (get_feature_names_out of the "poly" step with the
    #         input names X_train.columns) and the coefficients of the "reg" step (coef_)
    feature_names = ...
    coefs = ...

    coef_table = pd.Series(coefs, index=feature_names)

    # TODO 2: number of coefficients that are zero within the tolerance (np.isclose with atol=1e-10, rtol=0)
    n_zero = ...

    # TODO 3: the 15 coefficients with the largest absolute value, sorted by their value (for the bar chart)
    top = ...

    coef_summary.append({
        "model": name,
        "L2_norm": np.linalg.norm(coefs),
        "max_abs_coef": np.abs(coefs).max(),
        "n_zero": n_zero,
        "n_coefs": len(coefs),
    })

    # use different colors for positive and negative coefficients
    colors = np.where(top >= 0, "steelblue", "coral")

    fig, ax = plt.subplots(figsize=(9, 6))
    ax.barh(top.index, top.values, color=colors)
    ax.axvline(0, color="black", linewidth=0.8)

    ax.set_xlabel("Coefficient value")
    ax.set_ylabel("Polynomial feature")
    ax.set_title(f"{name}: 15 largest coefficients by absolute value\n"
                 f"Zero coefficients: {n_zero} of {len(coefs)}")

    ax.legend(handles=[Patch(facecolor="steelblue", label="Positive coefficient"),\
                       Patch(facecolor="coral", label="Negative coefficient")])

    ax.grid(axis="x", alpha=0.25)
    ax.set_axisbelow(True)

    plt.tight_layout()
    plt.show()

# summary table for all models
print(pd.DataFrame(coef_summary).round(2).to_string(index=False))

Dokumentácia: PolynomialFeatures.get_feature_names_out, numpy.isclose, pandas.Series.nlargest

Krok 3: Regularizačná cesta a stabilita výberu korelovaných príznakov Anchor

V Kroku 2 sme porovnávali modely pri pevne stanovenej hodnote hyperparametra alpha. V tejto časti sa zameriame na dva aspekty metódy Lasso, ktoré nemožno dostatočne posúdiť na základe jediného nastavenia regularizácie. Najskôr preskúmame priebeh odhadovaných koeficientov v závislosti od hodnoty hyperparametra alpha, označovaný ako regularizačná cesta. Následne vyhodnotíme stabilitu výberu príznakov pri miernych zmenách trénovacej vzorky v prítomnosti silnej korelácie medzi príznakmi.

Úloha 3.1 - Regularizačná cesta modelu Lasso Anchor

Preskúmajte, ako hodnota hyperparametra alpha ovplyvňuje koeficienty modelu Lasso. Pre zachovanie čitateľnosti grafu použijeme 10 pôvodných príznakov bez polynomického rozšírenia. Funkcia lasso_path vypočíta koeficienty pre postupnosť hodnôt alpha, čo umožňuje sledovať priebeh koeficientu každého príznaku pozdĺž regularizačnej cesty.

Pracujte iba s trénovacou množinou X_train, y_train. Vstupné príznaky štandardizujte a cieľovú premennú centrujte odčítaním jej priemeru na trénovacej množine, pretože funkcia lasso_path neodhaduje absolútny člen.

Doplňte časti kódu označené komentárom TODO v kostre nižšie. Kód následne vypíše poradie prvého vstupu príznakov do modelu na použitej mriežke hodnôt alpha. Za vstup považujeme situáciu, keď absolútna hodnota koeficientu pri znižovaní alpha prvýkrát prekročí toleranciu 1e-10. Viaceré príznaky môžu vstúpiť v rovnakom kroku.

V grafe identifikujte hodnoty alpha, pri ktorých sú všetky koeficienty numericky nulové, a opíšte, ako sa koeficienty menia pri postupnom oslabovaní regularizácie. Poradie vstupu príznakov interpretujte ako vlastnosť konkrétnej regularizačnej cesty, nie ako všeobecné poradie ich dôležitosti.

Zdrojový kód

from sklearn.linear_model import lasso_path

# lasso_path fits no intercept, so the features are standardized and the target is centered
# TODO 1: standardize the original training features (StandardScaler, fit_transform on X_train)
#         and center the target (y_train minus its mean, as a NumPy array)
X_train_scaled = ...
y_train_centered = ...

# TODO 2: coefficient paths with lasso_path for alphas=np.logspace(2, -3, 100) and max_iter=50_000;
#         it returns (alphas, coefs, dual_gaps), where coefs has the shape (n_features, n_alphas)
alphas_path, coefs_path, _ = ...

# entry of each feature: the largest alpha with |coefficient| > 1e-10
# (alphas_path is decreasing, so it is the first such position on the path)
entered = np.abs(coefs_path) > 1e-10
entry_alpha = pd.Series(
    [alphas_path[row.argmax()] if row.any() else np.nan for row in entered],
    index=X_train.columns,
).sort_values(ascending=False)
print("Order in which the features enter the model (alpha at which the coefficient becomes non-zero):")
print(entry_alpha.round(3).to_string())

# plot one regularization path per original feature
fig, ax = plt.subplots(figsize=(10, 6))

for feature, path in zip(X_train.columns, coefs_path):
    ax.plot(alphas_path, path, label=feature)

# moving right corresponds to weaker regularization
ax.set_xscale("log")
ax.invert_xaxis()
ax.axhline(0, color="grey", linestyle="--", linewidth=0.8)

ax.set_xlabel("alpha (right = weaker regularization)")
ax.set_ylabel("Coefficient value")
ax.set_title("Lasso regularization path")
ax.legend(bbox_to_anchor=(1.02, 1), loc="upper left")

plt.tight_layout()
plt.show()

Poradie vstupu príznakov do modelu závisí aj od ich vzájomných korelácií, preto ho nemožno interpretovať ako jednoznačné poradie ich dôležitosti. Regularizačná cesta slúži na analýzu priebehu koeficientov v závislosti od sily regularizácie. Vhodnú hodnotu hyperparametra alpha následne zvolíme na základe validačnej chyby odhadnutej pomocou krížovej validácie.

Upozornenie

V tomto grafe hodnota alpha smerom doprava klesá, a teda regularizácia slabne. Smerom doľava sa regularizácia zosilňuje a podporuje zmenšovanie koeficientov až na nulu. Pri interpretácii preto sledujte hodnoty na osi, nielen smer pohybu v grafe.

Dokumentácia: lasso_path, StandardScaler

Úloha 3.2 - Stabilita výberu pri korelovaných príznakoch Anchor

V predchádzajúcej úlohe sme sledovali zmeny koeficientov pri rôznych hodnotách hyperparametra alpha. Teraz ponecháme jeho hodnotu konštantnú a preskúmame, ako výber príznakov ovplyvňujú zmeny trénovacej vzorky.

K pôvodným príznakom v množine X_train pridajte dve takmer identické kópie príznaku bmi. Každú vytvorte pridaním nezávislého náhodného šumu s malou smerodajnou odchýlkou vzhľadom na variabilitu bmi. Kópie vytvorte iba raz, pred bootstrapovaním. Polynomické rozšírenie v tejto úlohe nepoužívajte.

Následne vytvorte 50 bootstrapových vzoriek. Každú získajte náhodným výberom rovnakého počtu pozorovaní, aký obsahuje trénovacia množina, s opakovaním. Vstupy a zodpovedajúce cieľové hodnoty vyberajte spoločne pomocou rovnakých indexov.

Na každej vzorke natrénujte Pipeline s krokmi StandardScaler a Lasso, pričom vo všetkých opakovaniach použite rovnakú hodnotu alpha. Zaznamenajte, ktoré z troch príznakov - pôvodný bmi a jeho dve kópie - majú absolútnu hodnotu koeficientu väčšiu než 1e-10.

Doplňte časti kódu označené komentárom TODO v kostre nižšie.

Zdrojový kód

from sklearn.utils import resample

# create two strongly correlated copies of BMI
rng = np.random.default_rng(RANDOM_STATE)
X_corr = X_train.copy()
# noise SD = 5 % of the bmi SD -> the copies correlate with bmi at about 0.999
noise_std = 0.05 * X_train["bmi"].std(ddof=0)

# TODO 1: add the columns "bmi_copy_1" and "bmi_copy_2" to X_corr: the bmi column plus independent
#         noise rng.normal(0, noise_std, len(X_corr)) for each copy
...

# track how often each feature has a non-zero coefficient
tracked = ["bmi", "bmi_copy_1", "bmi_copy_2"]
selection_counts = pd.Series(0, index=tracked, dtype=int)
n_bootstrap = 50

for seed in range(n_bootstrap):
    # TODO 2: bootstrap sample - rows of X_corr and y_train drawn with replacement
    #         (resample with replace=True and random_state=seed keeps features and targets aligned)
    X_boot, y_boot = ...

    # TODO 3: pipeline with the steps "scaler" (StandardScaler) and "lasso" (Lasso(alpha=2.0, max_iter=50_000)),
    #         fitted on the bootstrap sample
    model = ...

    coefs = pd.Series(model.named_steps["lasso"].coef_, index=X_corr.columns)
    # TODO 4: boolean mask of the tracked features with a non-zero coefficient
    #         (negated np.isclose with atol=1e-10, rtol=0)
    selected = ...
    selection_counts += selected.astype(int)

# report selection counts and frequencies across bootstrap samples
selection_results = pd.DataFrame({
    "selection_count": selection_counts,
    "selection_frequency": selection_counts / n_bootstrap,
})

print(selection_results.sort_values("selection_count", ascending=False))

Dokumentácia: resample, Lasso, ElasticNet

Krok 4: Výber sily regularizácie pomocou krížovej validácie Anchor

Doteraz sme skúmali, ako regularizácia ovplyvňuje koeficienty modelu a stabilitu výberu príznakov. Teraz sa zameriame na výber jej sily. Príliš slabá regularizácia nemusí dostatočne obmedziť pretrénovanie, zatiaľ čo príliš silná môže viesť k podtrénovaniu.

Vhodnú hodnotu hyperparametra alpha budeme hľadať pomocou krížovej validácie na trénovacích dátach. Najskôr zobrazíme závislosť trénovacej a validačnej chyby od hodnoty hyperparametra alpha pomocou validačnej krivky. Následne vyberieme konfiguráciu podľa validačnej RMSE. Odloženú testovaciu množinu použijeme až na záverečné vyhodnotenie zvoleného modelu.

Ladenie ukážeme na modeli Ridge s polynomickými príznakmi druhého stupňa. Tento výber slúži didaktickému cieľu a neznamená, že daná konfigurácia prekonáva všetky modely z predchádzajúcich úloh.

Úloha 4.1 - Validačná krivka Anchor

Pre model Ridge s polynomickými príznakmi druhého stupňa preskúmajte hodnoty hyperparametra alpha z mriežky alpha_grid = np.logspace(-4, 4, 30). Použite Pipeline s krokmi PolynomialFeatures, StandardScaler a Ridge, pričom nastavte degree=2 a include_bias=False.

Pracujte s pôvodnými príznakmi z množiny X_train, bez pridaných kópií príznaku bmi z Úlohy 3.2. Pomocou funkcie validation_curve vyhodnoťte všetky nastavenia na rovnakých rozdeleniach päťnásobnej krížovej validácie ako v predchádzajúcich porovnaniach. Použite scoring="neg_root_mean_squared_error" a pri spracovaní výsledkov zmeňte znamienko skóre, aby ste získali hodnoty metriky RMSE.

Doplňte časti kódu označené komentárom TODO v kostre nižšie.

Kód vypíše hodnotu alpha s najnižšou priemernou validačnou hodnotou metriky RMSE. Túto hodnotu best_alpha použijeme v Kroku 5 na záverečné vyhodnotenie.

Zdrojový kód

from sklearn.model_selection import validation_curve

# TODO 1: pipeline with the steps "poly" (degree=2, include_bias=False), "scaler" and "ridge" (Ridge());
#         the step name "ridge" determines the parameter name "ridge__alpha" below
ridge_pipe = ...

# evaluate regularization strengths on the same CV splits
alpha_grid = np.logspace(-4, 4, 30)

# TODO 2: validation_curve for the parameter "ridge__alpha" over alpha_grid,
#         on the same folds cv and with scoring="neg_root_mean_squared_error"
train_scores, val_scores = ...

# convert negative scores to RMSE
train_rmse = -train_scores
val_rmse = -val_scores

# summarize results across folds for each alpha
train_mean = train_rmse.mean(axis=1)
train_sd = train_rmse.std(axis=1, ddof=1)
val_mean = val_rmse.mean(axis=1)
val_sd = val_rmse.std(axis=1, ddof=1)

# TODO 3: index of the alpha with the lowest mean validation RMSE and the corresponding alpha
best_idx = ...
best_alpha = ...

print(f"Best alpha from the grid: {best_alpha:.5g}")
print(f"Mean validation RMSE: {val_mean[best_idx]:.2f}")

# plot mean RMSE and fold variability
fig, ax = plt.subplots(figsize=(9, 5))
ax.plot(alpha_grid, train_mean, color="steelblue", label="Training RMSE")
ax.fill_between(alpha_grid, train_mean - train_sd, train_mean + train_sd, color="steelblue", alpha=0.2)
ax.plot(alpha_grid, val_mean, color="coral", label="Validation RMSE")
ax.fill_between(alpha_grid, val_mean - val_sd, val_mean + val_sd, color="coral", alpha=0.2)

# mark the best value from the evaluated grid
ax.axvline(best_alpha, color="grey", linestyle="--", label=f"Selected alpha = {best_alpha:.3g}")
ax.scatter(best_alpha, val_mean[best_idx], color="coral", edgecolor="black", zorder=3)

# moving right corresponds to stronger regularization
ax.set_xscale("log")
ax.set_xlabel("alpha (right = stronger regularization)")
ax.set_ylabel("RMSE")
ax.set_title("Validation curve of Ridge regression")
ax.legend()
ax.grid(alpha=0.25)

plt.tight_layout()
plt.show()

Upozornenie

Pásma okolo kriviek vyjadrujú variabilitu medzi foldmi, nie intervaly spoľahlivosti.

Nesprávny postup je vypočítať testovaciu hodnotu metriky RMSE pre každé alpha a ponechať najlepšie. Hoci sa na teste nefitujú koeficienty, informácia z testu by riadila výber modelu a výsledná testová chyba by už nebola nezávislým odhadom.

Tip

V praxi sa na výber hyperparametra často používa GridSearchCV. Robí to isté ako výber minima validačnej krivky (rovnaká mriežka, rovnaké foldy, rovnaká metrika) a pri refit=True navyše natrénuje model so zvolenou hodnotou na celej trénovacej množine. My tento krok urobíme ručne v Úlohe 5.1.

Dokumentácia: validation_curve, GridSearchCV

Krok 5: Záverečné vyhodnotenie modelu Anchor

Po dokončení ladenia vyhodnotíme zvolený model na dátach, ktoré neboli použité pri učení ani pri výbere hyperparametrov. Odložená testovacia množina poskytne záverečný odhad jeho generalizačnej schopnosti.

Úloha 5.1 - Jednorazové vyhodnotenie na testovacej množine Anchor

Model Ridge s hodnotou best_alpha z Úlohy 4.1 natrénujte na celej trénovacej množine a jediný raz ho vyhodnoťte na odloženej testovacej množine. Vypočítajte:

  • testovaciu hodnotu metriky RMSE,
  • testovaciu hodnotu metriky MAE,
  • koeficient determinácie R2.

Doplňte časti kódu označené komentárom TODO v kostre nižšie.

Zdrojový kód

from sklearn.base import clone
from sklearn.metrics import mean_absolute_error, r2_score, root_mean_squared_error

# final model: a copy of the Task 4.1 pipeline with the selected alpha, fitted on the whole training set
# (clone keeps ridge_pipe itself unchanged)
final_model = clone(ridge_pipe).set_params(ridge__alpha=best_alpha)
final_model.fit(X_train, y_train)
cv_rmse = val_mean[best_idx]

# record the selected configuration BEFORE looking at the test set
print(f"Selected alpha:       {best_alpha:.4g}")
print(f"Mean CV RMSE (4.1):   {cv_rmse:.2f}")

# TODO 1: predictions of final_model for X_test
y_pred = ...

# TODO 2: test RMSE, MAE and R^2 (compare y_test with y_pred)
test_rmse = ...
test_mae = ...
test_r2 = ...

print(f"\nTest RMSE:  {test_rmse:.2f}")
print(f"Test MAE:   {test_mae:.2f}")
print(f"Test R^2:   {test_r2:.3f}")
print(f"Difference test - CV RMSE: {test_rmse - cv_rmse:+.2f}")

# reference model: always predicts the training mean
baseline_rmse = root_mean_squared_error(y_test, np.full(len(y_test), y_train.mean()))
print(f"RMSE of the reference model (mean of y_train): {baseline_rmse:.2f}")

(Prečo sa testová RMSE líši od priemernej CV RMSE a aké obmedzenia má záver založený na jednej malej dátovej sade a jednom testovacom rozdelení, prediskutujeme na cvičení.)

Výsledok testu je konečný

Po zobrazení testových výsledkov už podľa nich neupravujte model, hodnotu alpha ani rozdelenie dát. Aj nepriaznivý výsledok je súčasťou korektného vyhodnotenia.

Dokumentácia: clone, root_mean_squared_error, mean_absolute_error, r2_score

Doplňujúce úlohy (bonus) Anchor

Doplňujúce úlohy riešte pomocou krížovej validácie na trénovacej množine. Testovacie vyhodnotenie z Kroku 5 je uzavreté a už sa nemení.

  1. Pomocou learning_curve vykreslite krivky učenia ( learning curves) troch modelov Ridge z Úlohy 4.1, konkrétne so slabou regularizáciou (alpha=1e-4), s hodnotou best_alpha a so silnou regularizáciou (alpha=1e4). Použite rovnaké foldy cv a zobrazte priemernú trénovaciu a validačnú hodnotu metriky RMSE s pásmom ± jednej smerodajnej odchýlky medzi jednotlivými foldmi. Porovnajte generalizačnú medzeru pri najväčšej použitej veľkosti trénovacej vzorky a posúďte, pri ktorom modeli by ďalšie dáta ešte mohli znížiť validačnú chybu.
  2. Nalaďte model ElasticNet súčasne v dvoch hyperparametroch, alpha a l1_ratio, pomocou GridSearchCV na rovnakých foldoch cv. Priemernú validačnú RMSE všetkých kombinácií zobrazte ako tepelnú mapu ( heatmap). Najlepšiu kombináciu porovnajte s modelom Ridge z Úlohy 4.1 pomocou párových rozdielov RMSE na rovnakých foldoch a posúďte, či je výhoda jedného z modelov konzistentná naprieč foldmi.
  3. Zopakujte výber hodnôt hyperparametra alpha z Úlohy 4.1 pre viacero rozdelení dát vytvorených pomocou KFold s nastavením shuffle=True a rôznymi hodnotami random_state (napríklad pre 20 hodnôt). Zobrazte rozdelenie vybraných hodnôt best_alpha aj príslušných priemerných validačných hodnôt metriky RMSE. Zhodnoťte stabilitu výberu hyperparametra a vysvetlite, čo výsledky naznačujú o spoľahlivosti uvádzania jedinej „najlepšej“ hodnoty alpha.

Doplňujúce zdroje Anchor


Top