Cvičenie 4 – Skupinové metódy

Týždeň 4 · numpy, pandas, matplotlib, scikit-learn ≥ 1.4, xgboost, lightgbm · zdroj: pok-isi.fei.tuke.sk

Ako čítať túto stránku Pri každej úlohe je stručné zadanie, doplnené riešenie (miesta TODO), výstup z tvojho notebooku a odpovede na otázky na diskusiu vyvodené z tvojich výsledkov.

Úvod a ciele

Skupinové metódy (ensemble methods) spájajú viacero základných modelov. Ich prínos závisí od kvality jednotlivých modelov aj od toho, nakoľko sa líšia ich chyby. Rozmanitosť vzniká náhodným výberom dát a príznakov (bagging), postupným učením (boosting) alebo kombináciou rôznych typov modelov (voting, stacking).

  1. Vysvetliť rozdiel medzi homogénnymi a heterogénnymi skupinovými modelmi a význam rozmanitosti.
  2. Vyhodnotiť prínos agregácie stromov pre výkonnosť a stabilitu.
  3. Natrénovať boosting s predčasným zastavením a vysvetliť vzťah learning rate ↔ počet iterácií.
  4. Použiť XGBoost a LightGBM s natívnymi kategorickými príznakmi a porovnať s RandomForest.
  5. Zostaviť heterogénne modely (voting, stacking) a porovnať ich.

Teoretické minimum

Homogénny vs. heterogénny
Homogénny = základné modely rovnakého typu (napr. stromy). Heterogénny = rôzne typy (strom + lineárny model). Kombinácia pomáha len vtedy, keď modely robia aspoň čiastočne odlišné chyby – heterogenita to sama nezaručuje.
Bagging
Modely sa učia nezávisle, každý na vlastnej bootstrapovej vzorke (výber s opakovaním). Predikcie sa priemerujú. Znižuje rozptyl – hlavne pri nestabilných modeloch (hlboké stromy). Náhodný les navyše pri každom delení vyberá len podmnožinu príznakov → stromy sú menej podobné.
Boosting
Modely sa učia postupne, každý nový opravuje chyby doterajšieho ansámblu. Pri gradientovom boostingu príspevok stromu škáluje learning rate. Znižuje vychýlenie, ale môže sa pretrénovať → early stopping.
Voting a stacking
Hard voting = väčšina tried, soft voting = priemer pravdepodobností (tu s rovnakými váhami). Stacking = meta-model sa učí, ako skombinovať predikcie základných modelov; trénuje sa na out-of-fold predikciách (krížová validácia), aby nevidel predikcie na trénovacích dátach.

Dáta a príprava

Adult Income – 48 842 záznamov zo sčítania USA (1994). Cieľ: príjem > 50 000 USD. Binárna klasifikácia s nevyváženými triedami (~24 % pozitívnych). Zmiešané číselné a kategorické príznaky, tri kategorické majú chýbajúce hodnoty.

  • tree_prep – OrdinalEncoder pre kategórie (chýbajúce/neznáme → −1), čísla bez zmeny. Stromom stačia celočíselné kódy.
  • linear_prep – imputácia + OneHotEncoder pre kategórie, StandardScaler pre čísla. Lineárny model potrebuje one-hot a škálovanie.
  • Oba sú prvým krokom v Pipeline, takže sa v každom folde učia len z jeho trénovacej časti (žiadny únik dát).
import time

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

from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.impute import SimpleImputer
from sklearn.model_selection import StratifiedKFold, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler

RANDOM_STATE = 42

# fetch the Adult Income dataset
data = fetch_openml("adult", version=2, as_frame=True)

# drop 'fnlwgt' (a survey weight, not a personal attribute) and 'education' attributes
X = data.data.drop(columns=["fnlwgt", "education"])
y = (data.target == ">50K").astype(int)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, stratify=y, random_state=RANDOM_STATE)

cat_cols = X.select_dtypes("category").columns.tolist()
num_cols = X.select_dtypes("number").columns.tolist()

# the same stratified folds are used in all tasks
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=RANDOM_STATE)

# tree-based models only need integer codes
# missing and unseen categories get the code -1
tree_prep = ColumnTransformer(
    [("cat", OrdinalEncoder(handle_unknown="use_encoded_value", unknown_value=-1, encoded_missing_value=-1), cat_cols)],
    remainder="passthrough",
)

# a linear model needs one-hot encoded categories and scaled numerical features
linear_prep = ColumnTransformer([
    ("cat", make_pipeline(SimpleImputer(strategy="most_frequent"), OneHotEncoder(handle_unknown="ignore")), cat_cols),
    ("num", StandardScaler(), num_cols),
])

print(f"Training set: {X_train.shape}, test set: {X_test.shape}\n")
print(f"Share of the positive class (>50K): {y_train.mean():.3f}\n")
print(f"Categorical features: {cat_cols}\n")
print(f"Numerical features: {num_cols}")

Výstup

Training set: (39073, 12), test set: (9769, 12)

Share of the positive class (>50K): 0.239

Categorical features: ['workclass', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country']

Numerical features: ['age', 'education-num', 'capital-gain', 'capital-loss', 'hours-per-week']
PoznámkaModely porovnávame metrikou roc_auc_score na rovnakých 5 stratifikovaných foldoch. Úlohy 1.2 a 2.1 používajú jedno rozdelenie trénovacej množiny na fit/val. Testovacia množina sa použije iba raz – v úlohe 5.1.

Krok 1 – Agregácia cez bootstrap (bagging)

Úloha 1.1 – Od jedného stromu k náhodnému lesu

Porovnať DecisionTreeClassifier bez obmedzenia hĺbky s BaggingClassifier (100 stromov) a RandomForestClassifier (100 stromov). Všetko v pipeline s tree_prep, 5-fold CV, trénovacie aj validačné AUC.

Riešenie

from sklearn.ensemble import BaggingClassifier, RandomForestClassifier
from sklearn.model_selection import cross_validate
from sklearn.tree import DecisionTreeClassifier

homogeneous = {
    "Decision tree": make_pipeline(tree_prep, DecisionTreeClassifier(random_state=RANDOM_STATE)),
    # TODO 1: add required homogeneous classifiers, both as a pipeline with tree_prep,
    #         n_jobs=-1 and random_state=RANDOM_STATE
    "Bagging": make_pipeline(
        tree_prep,
        BaggingClassifier(estimator=DecisionTreeClassifier(), n_estimators=100, n_jobs=-1, random_state=RANDOM_STATE),
    ),
    "Random forest": make_pipeline(
        tree_prep,
        RandomForestClassifier(n_estimators=100, n_jobs=-1, random_state=RANDOM_STATE),
    ),
}

rows = []
for name, model in homogeneous.items():
    # TODO 2: add 5-fold CV on the folds cv with scoring="roc_auc", including the training scores
    scores = cross_validate(model, X_train, y_train, cv=cv, scoring="roc_auc", return_train_score=True)

    rows.append({
        "model": name,
        "train_AUC": scores["train_score"].mean(),
        "validation_AUC": scores["test_score"].mean(),
        "validation_SD": scores["test_score"].std(ddof=1),
        "fit_time_s": scores["fit_time"].mean(),
    })

homogeneous_results = pd.DataFrame(rows).set_index("model")
print(homogeneous_results.round(4))

Výstup

modeltrain_AUCvalidation_AUCvalidation_SDfit_time_s
Decision tree0.99830.76310.00570.0964
Bagging0.99720.88930.00634.8307
Random forest0.99730.89580.00570.3903
OtázkaPri ktorom modeli je rozdiel train vs. validácia najväčší, ako sa po agregácii mení validačné AUC a čo to hovorí o zovšeobecňovaní?
Odpoveď
  • Najväčší rozdiel má samostatný strom: 0.9983 vs. 0.7631 → rozdiel ≈ 0.235. Strom si dáta zapamätá (pretrénovanie, vysoký rozptyl) a na nových dátach zovšeobecňuje slabo.
  • Agregácia zvýši validačné AUC o ~0.13 (Bagging 0.889, RF 0.896), hoci trénovacie AUC zostáva takmer 1. Priemerovanie mnohých nestabilných stromov znižuje rozptyl – chyby jednotlivých stromov sa navzájom čiastočne rušia.
  • RF je lepší než Bagging, lebo náhodný výber príznakov pri delení robí stromy menej korelovanými → priemerovanie odstráni viac rozptylu. Navyše bol v tvojom behu ~12× rýchlejší.
  • Rozdiel train–val ~0.10 ostáva aj pri ansámbloch – plne rozvinuté stromy stále pamätajú trénovacie dáta. Samotné trénovacie AUC preto nie je dobrým ukazovateľom kvality.
  • Časť veľkého skoku spôsobuje aj AUC: strom dáva takmer len pravdepodobnosti 0/1, takže nevie dobre zoradiť pozorovania; les dáva spojité pravdepodobnosti.

Úloha 1.2 – Ako vzniká predikcia náhodného lesa

Natrénovať RF s 200 stromami na X_fit, pre každý strom spočítať pravdepodobnosť pozitívnej triedy na X_val a potom priebežný priemer prvých k stromov.

Riešenie (doplnené TODO)

from sklearn.metrics import accuracy_score, roc_auc_score

# one split of the training set for inspecting a single fitted model
X_fit, X_val, y_fit, y_val = train_test_split(X_train, y_train, test_size=0.25, stratify=y_train, random_state=RANDOM_STATE)

forest = make_pipeline(tree_prep, RandomForestClassifier(n_estimators=200, oob_score=True, n_jobs=-1, random_state=RANDOM_STATE))
forest.fit(X_fit, y_fit)
rf = forest[-1]
X_val_enc = forest[:-1].transform(X_val)

# TODO 1: probability of the positive class from every single tree in rf.estimators_
#         (predict_proba on X_val_enc), as an array of shape (n_trees, n_validation_rows)
tree_proba = np.array([tree.predict_proba(X_val_enc)[:, 1] for tree in rf.estimators_])
tree_auc = np.array([roc_auc_score(y_val, proba) for proba in tree_proba])

# TODO 2: probabilities of a forest built from the first k trees, for k = 1 ... n_trees
#         (running mean of tree_proba over the trees: np.cumsum along axis 0 divided by k)
n_trees = np.arange(1, len(tree_proba) + 1)
ensemble_proba = np.cumsum(tree_proba, axis=0) / n_trees[:, None]
ensemble_auc = np.array([roc_auc_score(y_val, proba) for proba in ensemble_proba])

# diversity of the base models: mean correlation between the predictions of two different trees
tree_corr = np.corrcoef(tree_proba)
mean_tree_corr = tree_corr[np.triu_indices_from(tree_corr, k=1)].mean()

print(f"AUC of a single tree: mean {tree_auc.mean():.4f}, min {tree_auc.min():.4f}, max {tree_auc.max():.4f}")
print(f"AUC of the forest ({len(tree_proba)} trees): {ensemble_auc[-1]:.4f}")
print(f"Mean correlation between two trees: {mean_tree_corr:.3f}")
print(f"Out-of-bag accuracy: {rf.oob_score_:.4f}, validation accuracy: {accuracy_score(y_val, forest.predict(X_val)):.4f}")

# every dot is one base tree, the line is the forest built from the first k trees
fig, ax = plt.subplots(figsize=(9, 5))
ax.scatter(n_trees, tree_auc, s=12, color="grey", alpha=0.6, label="Single tree")
ax.plot(n_trees, ensemble_auc, color="steelblue", linewidth=2, label="Forest of the first k trees")

ax.set_xscale("log")
ax.set_xlabel("Number of trees k (log scale)")
ax.set_ylabel("Validation AUC")
ax.set_title("Base trees and their aggregation")
ax.legend()
ax.grid(alpha=0.25)

plt.tight_layout()
plt.show()

Výstup

AUC of a single tree: mean 0.7584, min 0.7449, max 0.7717
AUC of the forest (200 trees): 0.9006
Mean correlation between two trees: 0.573
Out-of-bag accuracy: 0.8477, validation accuracy: 0.8530
AUC jednotlivých stromov a lesa podľa počtu stromov
Sivé body = jednotlivé stromy, modrá čiara = les z prvých k stromov (log. os x).
OtázkaPorovnajte AUC stromov s AUC lesa. Pri akom počte stromov sa zlepšovanie prakticky zastaví?
Odpoveď
  • Každý strom má AUC len 0.745–0.772, les z 200 stromov 0.9006. Už les z 2 stromov (~0.82) je lepší než najlepší jednotlivý strom.
  • Krivka strmo rastie do ~10–20 stromov (~0.875–0.885), pri ~40 stromoch je ~0.895, pri 100 ~0.899 a ďalej už len 0.9006. Zlepšovanie sa prakticky zastaví okolo 50–100 stromov; ďalšie stromy už nepridávajú, ale ani neškodia (len zvyšujú výpočtový čas).
  • Priemerná korelácia dvoch stromov 0.573 je pomerne nízka – stromy sú dostatočne rozmanité, preto priemer pomáha. Keby bola korelácia blízko 1, priemerovanie by takmer nič neprinieslo.
  • OOB accuracy 0.8477 vs. validačná 0.8530 – takmer zhodné. OOB odhad je spoľahlivý odhad výkonnosti bez samostatnej validačnej množiny (každý strom nevidel ~⅓ dát).

Krok 2 – Postupné posilňovanie (boosting)

Úloha 2.1 – Rýchlosť učenia a predčasné zastavenie

HistGradientBoostingClassifier s learning_rate ∈ {0.03, 0.1, 0.3, 1.0}, max_iter=1000, early stopping na 20 % dát z X_fit, trpezlivosť 20 iterácií, categorical_features="from_dtype".

Riešenie (doplnené TODO)

from sklearn.ensemble import HistGradientBoostingClassifier

rows = []
curves = {}

for learning_rate in [0.03, 0.1, 0.3, 1.0]:
    # TODO 1: add HistGradientBoostingClassifier with the given configuration
    #         and random_state=RANDOM_STATE
    model = HistGradientBoostingClassifier(
        learning_rate=learning_rate,
        max_iter=1000,
        early_stopping=True,
        validation_fraction=0.2,
        n_iter_no_change=20,
        categorical_features="from_dtype",
        random_state=RANDOM_STATE,
    )

    start = time.perf_counter()
    model.fit(X_fit, y_fit)
    fit_time = time.perf_counter() - start

    # TODO 2: training and validation log loss after each iteration as a tuple
    #         (train_score_ and validation_score_ store the negative log loss)
    curves[learning_rate] = (-model.train_score_, -model.validation_score_)


    rows.append({
        "learning_rate": learning_rate,
        "n_iterations": model.n_iter_,
        "validation_AUC": roc_auc_score(y_val, model.predict_proba(X_val)[:, 1]),
        "fit_time_s": fit_time,
    })

boosting_results = pd.DataFrame(rows).set_index("learning_rate")
print(boosting_results.round(4))

# every iteration adds one tree that corrects the errors of the current ensemble
fig, ax = plt.subplots(figsize=(9, 5))
for learning_rate, (train_loss, validation_loss) in curves.items():
    line, = ax.plot(validation_loss, label=f"learning_rate = {learning_rate}")
    ax.plot(train_loss, linestyle="--", color=line.get_color(), alpha=0.6)

# limit the y-axis so that a single curve cannot hide the others
ax.set_ylim(0.25, 0.60)
ax.set_xscale("log")
ax.set_xlabel("Boosting iteration (log scale)")
ax.set_ylabel("Log loss (solid = validation, dashed = training)")
ax.set_title("Boosting: loss after each added tree")
ax.legend()
ax.grid(alpha=0.25)

plt.tight_layout()
plt.show()
Prečo znamienko mínustrain_score_ a validation_score_ ukladajú zápornú log loss (väčšie = lepšie), preto ich negujeme, aby sme dostali chybu.

Výstup

learning_raten_iterationsvalidation_AUCfit_time_s
0.032820.93040.6851
0.101330.93000.4361
0.30500.92800.2213
1.00250.91020.1586
Log loss po každej iterácii boostingu
Plná čiara = validačná, prerušovaná = trénovacia log loss.
OtázkaAký je vzťah medzi rýchlosťou učenia a počtom iterácií a čo sa deje s validačnou chybou pri najvyššej rýchlosti?
Odpoveď
  • Nepriama úmera: čím väčší learning rate, tým väčší krok každého stromu a tým menej iterácií treba (282 → 133 → 50 → 25). Učenie je rýchlejšie (0.69 s → 0.16 s).
  • Menší learning rate dáva mierne lepší výsledok (0.9304 / 0.9300), lebo model postupuje jemnejšie a výsledný súčet mnohých malých krokov je stabilnejší (forma regularizácie). Rozdiel medzi 0.03 a 0.1 je však zanedbateľný, 0.1 je dobrý kompromis rýchlosť/kvalita.
  • Pri learning_rate = 1.0 validačná chyba najprv rýchlo klesne (minimum ~0.30 okolo 5. iterácie), potom začne rásť a je nestabilná – okolo 10.–13. iterácie dokonca vyskočí nad 0.6 (príliš veľké kroky „prestrelia“). Model sa rýchlo pretrénuje, AUC padne na 0.9102.
  • Early stopping zastavil po 25 iteráciách: najlepšia iterácia + 20 iterácií trpezlivosti. Bez neho by sa model ďalej zhoršoval.
  • Trénovacia chyba (prerušovaná) pri menších rýchlostiach ďalej klesá aj keď validačná už stagnuje – presne vtedy má zmysel zastaviť.

Krok 3 – Ďalšie implementácie gradientového boostingu

Úloha 3.1 – Porovnanie XGBoost a LightGBM

RF (min_samples_leaf=5) vs. HistGradientBoosting, XGBClassifier a LGBMClassifier; všetky boostingy learning_rate=0.1, 300 iterácií bez early stopping. XGBoost s tree_method="hist" a enable_categorical=True.

Riešenie (doplnené TODO)

from lightgbm import LGBMClassifier
from xgboost import XGBClassifier

boosting = {
    # leaves with at least 5 training rows keep the trees from memorizing single rows
    "Random forest": make_pipeline(
        tree_prep,
        RandomForestClassifier(n_estimators=100, min_samples_leaf=5, n_jobs=-1, random_state=RANDOM_STATE),
    ),
    "HistGradientBoosting": HistGradientBoostingClassifier(learning_rate=0.1, max_iter=300, early_stopping=False,
                                                           categorical_features="from_dtype", random_state=RANDOM_STATE,
    ),
    # TODO 1: add requested classifiers, both with n_jobs=-1 and random_state=RANDOM_STATE
    #         (LightGBM also with verbose=-1 to silence its training log)
    # "XGBoost":
    # "LightGBM":
    "XGBoost": XGBClassifier(
        n_estimators=300,
        learning_rate=0.1,
        tree_method="hist",
        enable_categorical=True,
        n_jobs=-1,
        random_state=RANDOM_STATE,
    ),
    "LightGBM": LGBMClassifier(
        n_estimators=300,
        learning_rate=0.1,
        n_jobs=-1,
        random_state=RANDOM_STATE,
        verbose=-1,
    ),

}

rows = []
for name, model in boosting.items():
    # TODO 2: add 5-fold CV on the folds cv with scoring="roc_auc"
    scores = cross_validate(model, X_train, y_train, cv=cv, scoring="roc_auc")


    rows.append({
        "model": name,
        "validation_AUC": scores["test_score"].mean(),
        "validation_SD": scores["test_score"].std(ddof=1),
        "fit_time_s": scores["fit_time"].mean(),
    })

library_results = pd.DataFrame(rows).set_index("model")
print(library_results.round(4))

Výstup

modelvalidation_AUCvalidation_SDfit_time_s
Random forest0.91810.00370.3694
HistGradientBoosting0.92730.00330.7253
XGBoost0.92740.00340.8102
LightGBM0.92800.00330.5085
OtázkaPri ktorých modeloch je rozdiel väčší než variabilita medzi foldmi a dá sa určiť poradie troch boostingových implementácií?
Odpoveď
  • RF vs. boosting: rozdiel ~0.009–0.010 je ~3× väčší než SD (~0.0035). Boosting je tu teda jasne lepší než náhodný les.
  • Medzi HGB, XGBoost a LightGBM sú rozdiely najviac 0.0007 – hlboko pod SD ~0.0033. Poradie sa určiť nedá; všetky tri sú prakticky rovnako dobré (aj preto, že všetky používajú histogramové gradientové boostovanie s podobnými nastaveniami).
  • Prísnejšie by bolo porovnať párové rozdiely na rovnakých foldoch (rovnaké foldy sú pre všetky modely podobne ťažké), ale pri takto malých rozdieloch to záver nezmení.
  • Prakticky teda rozhoduje skôr rýchlosť: LightGBM bol najrýchlejší z boostingov (0.51 s/fold), XGBoost najpomalší (0.81 s).

Krok 4 – Heterogénne skupinové metódy

Úloha 4.1 – Rozmanitosť predikcií a hlasovanie

Out-of-fold pravdepodobnosti štyroch základných modelov (LogReg, RF, XGBoost, LightGBM) cez cross_val_predict; dve kombinácie soft voting (3 stromové / všetky 4); Spearmanova korelačná matica predikcií.

Riešenie (doplnené TODO)

from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_predict

base_models = {
    "Logistic regression": make_pipeline(linear_prep, LogisticRegression(max_iter=1000)),
    "Random forest": boosting["Random forest"],
    "XGBoost": boosting["XGBoost"],
    "LightGBM": boosting["LightGBM"],
}
tree_models = ["Random forest", "XGBoost", "LightGBM"]

# TODO 1: out-of-fold probabilities of the positive class for every base model
#         (cross_val_predict on the folds cv with method="predict_proba", column 1)
oof = pd.DataFrame({
    name: cross_val_predict(model, X_train, y_train, cv=cv, method="predict_proba")[:, 1]
    for name, model in base_models.items()
}, index=X_train.index)


def fold_auc(proba):
    """AUC of out-of-fold probabilities in each validation fold."""
    return np.array([
        roc_auc_score(y_train.iloc[val_idx], np.asarray(proba)[val_idx])
        for _, val_idx in cv.split(X_train, y_train)
    ])


fold_scores = {name: fold_auc(oof[name]) for name in base_models}

# TODO 2: soft voting - a VotingClassifier with voting="soft" over (name, model) pairs from base_models:
#         the three tree models (names in tree_models) and all four models
voting_models = {
    "Voting (3 tree models)": VotingClassifier(
        [(name, base_models[name]) for name in tree_models], voting="soft"),
    "Voting (all 4 models)": VotingClassifier(
        list(base_models.items()), voting="soft"
    ),
}

for name, model in voting_models.items():
    # TODO 3: 5-fold CV of the voting classifier on the folds cv with scoring="roc_auc"
    scores = cross_validate(model, X_train, y_train, cv=cv, scoring="roc_auc")
    fold_scores[name] = scores["test_score"]

voting_results = pd.DataFrame({
    "validation_AUC": {name: scores.mean() for name, scores in fold_scores.items()},
    "validation_SD": {name: scores.std(ddof=1) for name, scores in fold_scores.items()},
})
print(voting_results.round(4))

# TODO 4: Spearman correlation matrix of the out-of-fold predictions
#         (AUC depends only on the ranking of the rows, so the rank correlation is used)
oof_corr = oof.corr(method="spearman")

fig, ax = plt.subplots(figsize=(6, 5))
image = ax.imshow(oof_corr, cmap="Blues", vmin=0.7, vmax=1.0)
ax.set_xticks(range(len(oof_corr)), oof_corr.columns, rotation=30, ha="right")
ax.set_yticks(range(len(oof_corr)), oof_corr.index)
for i in range(len(oof_corr)):
    for j in range(len(oof_corr)):
        ax.text(j, i, f"{oof_corr.iloc[i, j]:.3f}", ha="center", va="center",
                color="white" if oof_corr.iloc[i, j] > 0.85 else "black")
ax.set_title("Rank correlation of the out-of-fold predictions")
fig.colorbar(image, ax=ax)

plt.tight_layout()
plt.show()

Výstup

modelvalidation_AUCvalidation_SD
Logistic regression0.90530.0044
Random forest0.91810.0037
XGBoost0.92740.0034
LightGBM0.92800.0033
Voting (3 tree models)0.92790.0034
Voting (all 4 models)0.92610.0036
Spearmanova korelácia out-of-fold predikcií
Spearmanova (poradová) korelácia out-of-fold predikcií.
modelpriemerná korelácia s ostatnými tromi
Logistic regression(0.941 + 0.904 + 0.900) / 3 = 0.915
Random forest(0.941 + 0.938 + 0.937) / 3 = 0.939
XGBoost(0.904 + 0.938 + 0.985) / 3 = 0.942
LightGBM(0.900 + 0.937 + 0.985) / 3 = 0.941
OtázkyKtorá dvojica má najpodobnejšie predikcie? Ktorý model má v priemere najnižšiu koreláciu s ostatnými? Zlepšilo pridanie logistickej regresie hlasovanie?
Odpoveď
  • Najpodobnejšie: XGBoost a LightGBM (ρ = 0.985) – oba sú gradientové boostingy s takmer rovnakým algoritmom, takže robia takmer rovnaké chyby.
  • Najnižšiu priemernú koreláciu má logistická regresia (≈ 0.915) – iný typ modelu (lineárny), teda najviac „odlišný“.
  • Voting 3 stromových modelov (0.9279) je prakticky na úrovni najlepšieho LightGBM (0.9280), nezlepší ho.
  • Pridanie LogReg hlasovanie zhoršilo (0.9279 → 0.9261). LogReg je síce najrozmanitejší, ale aj výrazne najslabší (0.9053). Pri rovnakých váhach jej horšie predikcie stiahnu priemer nadol viac, než pomôže jej odlišnosť. Rozmanitosť pomáha len vtedy, keď sú modely porovnateľne kvalitné.

Úloha 4.2 – Skladanie modelov (stacking)

StackingClassifier nad rovnakými štyrmi modelmi, meta-model = logistická regresia nad pravdepodobnosťami (bez pôvodných príznakov), vnútorná 5-fold CV, vonkajšia 5-fold CV na foldoch cv.

Riešenie (doplnené TODO)

from sklearn.ensemble import StackingClassifier

# TODO 1: StackingClassifier over the items of base_models with final_estimator=LogisticRegression(),
#         stack_method="predict_proba" and cv=5 (inner CV that produces the inputs of the meta-model)
stacking = StackingClassifier(
    estimators=list(base_models.items()),
    final_estimator=LogisticRegression(),
    stack_method="predict_proba",
    cv=5,
)


# TODO 2: outer 5-fold CV on the folds cv with scoring="roc_auc" and return_estimator=True
stack_scores = cross_validate(stacking, X_train, y_train, cv=cv, scoring="roc_auc", return_estimator=True)
fold_scores["Stacking"] = stack_scores["test_score"]

# weights that the meta-model assigns to the base models (mean over the outer folds)
meta_weights = pd.Series(
    np.mean([estimator.final_estimator_.coef_[0] for estimator in stack_scores["estimator"]], axis=0),
    index=list(base_models),
)
print("Meta-model coefficients:")
print(meta_weights.round(3).to_string())

# compare every combination with the best single model on the same folds
best_single = max(base_models, key=lambda name: fold_scores[name].mean())
candidates = [best_single, "Voting (3 tree models)", "Voting (all 4 models)", "Stacking"]

rows = []
for name in candidates:
    diff = fold_scores[name] - fold_scores[best_single]
    rows.append({
        "model": name,
        "validation_AUC": fold_scores[name].mean(),
        "validation_SD": fold_scores[name].std(ddof=1),
        "mean_diff_vs_best": diff.mean(),
        "folds_better": int((diff > 0).sum()),
    })

combination_results = pd.DataFrame(rows).set_index("model")
print(f"\nBest single model: {best_single}")
print(combination_results.round(4).to_string())

Výstup

Koeficient meta-modeluhodnota
Logistic regression0.500
Random forest2.021
XGBoost2.269
LightGBM2.007
modelAUCΔ vs bestfolds_better
LightGBM0.92800.00000
Voting (3 tree)0.9279−0.00012
Voting (all 4)0.9261−0.00190
Stacking0.9277−0.00031
OtázkyČo naznačujú koeficienty meta-modelu o prínose výkonnosti a rozmanitosti? Je rozdiel oproti najlepšiemu modelu pri niektorej kombinácii konzistentný vo všetkých foldoch?
Odpoveď
  • LogReg dostala najnižšiu váhu (0.50) – meta-model sa naučil, že jej predikcie pridávajú málo; na rozdiel od rovnakých váh pri votingu ju „stlmil“. Preto stacking (0.9277) dopadol lepšie než voting so 4 modelmi (0.9261).
  • Tri stromové modely majú podobné váhy (~2.0–2.3), hoci RF má výrazne nižšie AUC než XGBoost a LightGBM. Dôvod: XGBoost a LightGBM sú takmer identické (ρ = 0.985), takže si „delia“ jednu informáciu a ich váhy sa rozdelia medzi ne. RF je od nich odlišnejší (ρ ≈ 0.94) a prináša aspoň trochu novej informácie, preto dostane relatívne veľkú váhu.
  • Pri silne korelovaných vstupoch (multikolinearita) sú koeficienty nestabilné a nedajú sa čítať ako „dôležitosť“ modelu – mierne inými dátami by sa váha mohla presunúť napr. z XGBoost na LightGBM bez zmeny predikcií.
  • Žiadna kombinácia neprekonala LightGBM v priemere. Voting 3 stromov bol lepší v 2/5 foldoch, stacking v 1/5 – rozdiely −0.0001 a −0.0003 sú šum, nie konzistentný efekt.
  • Jediný konzistentný rozdiel je negatívny: voting všetkých 4 modelov bol horší v všetkých 5 foldoch (0/5, −0.0019).
  • Záver: keď sú najlepšie modely veľmi podobné a ostatné slabšie, kombinácia neprinesie zlepšenie. Ansámbl potrebuje modely, ktoré sú zároveň dobré aj rozmanité.

Krok 5 – Záverečné vyhodnotenie

Úloha 5.1 – Výber postupu a test

Vybrať postup s najvyšším priemerným CV AUC z combination_results, natrénovať jeho kópiu (clone) na celej trénovacej množine a raz vyhodnotiť na teste.

Riešenie (doplnené TODO)

from sklearn.base import clone

# the best single model, both voting classifiers from Task 4.1 and stacking from Task 4.2
final_candidates = {best_single: base_models[best_single], **voting_models, "Stacking": stacking}

# the procedure is selected by cross-validation only, BEFORE looking at the test set
final_name = combination_results["validation_AUC"].idxmax()
cv_auc = combination_results.loc[final_name, "validation_AUC"]
print(f"Selected procedure: {final_name}")
print(f"Mean CV AUC:        {cv_auc:.4f}")

# TODO 1: fit a clone of the selected procedure on the whole training set
final_model = clone(final_candidates[final_name]).fit(X_train, y_train)

# TODO 2: probabilities of the positive class for X_test and the test AUC
test_proba = final_model.predict_proba(X_test)[:, 1]
test_auc = roc_auc_score(y_test, test_proba)

print(f"\nTest AUC:           {test_auc:.4f}")
print(f"Difference test - CV AUC: {test_auc - cv_auc:+.4f}")

Výstup

Selected procedure: LightGBM
Mean CV AUC:        0.9280

Test AUC:           0.9291
Difference test - CV AUC: +0.0011
Interpretácia
  • CV vybrala samostatný LightGBM – kombinácie neprekonali najlepší základný model, takže jednoduchší model je aj rozumnejšia voľba (rýchlejší, ľahšie udržiavateľný).
  • Testovacie AUC 0.9291 je o +0.0011 vyššie než CV odhad, rozdiel je v rámci variability medzi foldmi (SD ≈ 0.0033). CV odhad bol spoľahlivý a výber postupu sa „nepretrénoval“ na validáciu.
  • clone zaručuje, že trénujeme nový, nenaučený model s rovnakými hyperparametrami (nie objekt ovplyvnený predchádzajúcimi fitmi).
Výsledok testu je konečnýPo pohľade na testovacie AUC už nemeníme výber ani nastavenia modelov – inak by test prestal byť nestranným odhadom.

Zhrnutie na cvičenie

  • Bagging/RF drasticky znižuje rozptyl hlbokého stromu: val AUC 0.763 → 0.896. RF > Bagging vďaka nižšej korelácii stromov.
  • Les sa zlepšuje s počtom stromov, ale saturuje okolo 50–100 stromov; OOB odhad ≈ validačný.
  • Boosting: learning rate a počet iterácií sú nepriamo úmerné; malý LR = mierne lepšie a stabilnejšie, LR = 1.0 sa rýchlo pretrénuje. Early stopping je nutnosť.
  • HGB, XGBoost a LightGBM sú výkonom nerozlíšiteľné (rozdiely ≪ SD), všetky jasne lepšie než RF.
  • Rozmanitosť sama nestačí: pridanie slabšej LogReg pri rovnakých váhach zhorší voting; stacking ju stlmí, ale ani tak neprekoná najlepší model.
  • Finálne: LightGBM, CV 0.9280, test 0.9291.

Doplňujúce úlohy (náčrt riešenia)

Riešiť len krížovou validáciou na trénovacej množine – test z kroku 5 je uzavretý.

1. RandomizedSearchCV pre LightGBM

from scipy.stats import loguniform, uniform, randint
from sklearn.model_selection import RandomizedSearchCV

param_dist = {
    "num_leaves": randint(15, 128),
    "learning_rate": loguniform(0.01, 0.2),
    "subsample": uniform(0.6, 0.4),          # 0.6 - 1.0
    "subsample_freq": [1],                   # subsample sa v LightGBM uplatni len pri freq > 0
    "colsample_bytree": uniform(0.6, 0.4),
    "reg_lambda": loguniform(1e-3, 10),
}
search = RandomizedSearchCV(
    LGBMClassifier(n_estimators=300, n_jobs=-1, random_state=RANDOM_STATE, verbose=-1),
    param_dist, n_iter=30, scoring="roc_auc", cv=cv, random_state=RANDOM_STATE, n_jobs=1,
)
search.fit(X_train, y_train)
print(search.best_params_, search.best_score_)

# parove rozdiely na rovnakych foldoch voci nastaveniu z Ulohy 3.1
best_idx = search.best_index_
tuned_folds = np.array([search.cv_results_[f"split{i}_test_score"][best_idx] for i in range(5)])
diff = tuned_folds - fold_scores["LightGBM"]
print("mean diff:", diff.mean().round(4), "folds better:", (diff > 0).sum(), "/ 5")

2. Optuna s rovnakým počtom konfigurácií

import optuna
from sklearn.model_selection import cross_val_score

def objective(trial):
    params = {
        "num_leaves": trial.suggest_int("num_leaves", 15, 127),
        "learning_rate": trial.suggest_float("learning_rate", 0.01, 0.2, log=True),
        "subsample": trial.suggest_float("subsample", 0.6, 1.0),
        "subsample_freq": 1,
        "colsample_bytree": trial.suggest_float("colsample_bytree", 0.6, 1.0),
        "reg_lambda": trial.suggest_float("reg_lambda", 1e-3, 10, log=True),
    }
    model = LGBMClassifier(n_estimators=300, n_jobs=-1, random_state=RANDOM_STATE, verbose=-1, **params)
    scores = cross_val_score(model, X_train, y_train, cv=cv, scoring="roc_auc")
    trial.set_user_attr("folds", scores.tolist())
    return scores.mean()

study = optuna.create_study(direction="maximize", sampler=optuna.samplers.TPESampler(seed=RANDOM_STATE))
study.optimize(objective, n_trials=30)        # rovnaky pocet ako n_iter v RandomizedSearchCV

optuna_folds = np.array(study.best_trial.user_attrs["folds"])
diff = optuna_folds - tuned_folds
print(study.best_value, "mean diff vs random:", diff.mean().round(4), "folds better:", (diff > 0).sum())

3. CatBoost ako ďalší základný model

from catboost import CatBoostClassifier

# CatBoost chce kategorie ako stringy (bez NaN)
cat_prep = ColumnTransformer(
    [("cat", SimpleImputer(strategy="constant", fill_value="missing"), cat_cols)],
    remainder="passthrough", verbose_feature_names_out=False,
).set_output(transform="pandas")

catboost = make_pipeline(
    cat_prep,
    CatBoostClassifier(iterations=300, learning_rate=0.1, cat_features=cat_cols,
                       random_seed=RANDOM_STATE, verbose=0),
)

oof["CatBoost"] = cross_val_predict(catboost, X_train, y_train, cv=cv, method="predict_proba")[:, 1]
print(oof.corr(method="spearman").loc["CatBoost", ["XGBoost", "LightGBM"]])

base_models_cb = {**base_models, "CatBoost": catboost}
stacking_cb = StackingClassifier(list(base_models_cb.items()), final_estimator=LogisticRegression(),
                                 stack_method="predict_proba", cv=5)
res = cross_validate(stacking_cb, X_train, y_train, cv=cv, scoring="roc_auc", return_estimator=True)
print("Stacking + CatBoost AUC:", res["test_score"].mean().round(4))
print(pd.Series(np.mean([e.final_estimator_.coef_[0] for e in res["estimator"]], axis=0),
                index=list(base_models_cb)).round(3))
Čo očakávaťLadenie zvyčajne prinesie zlepšenie rádovo ~0.001–0.003 AUC; dôležité je pozrieť sa, v koľkých foldoch je párový rozdiel kladný. CatBoost má vďaka iným kódovaniam kategórií (ordered target statistics) často o niečo nižšiu koreláciu s XGBoost/LightGBM, čo môže stackingu pomôcť viac než ďalší veľmi podobný boosting.

Doplňujúce zdroje