Cvičenie 4 – Skupinové metódy
Ú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).
- Vysvetliť rozdiel medzi homogénnymi a heterogénnymi skupinovými modelmi a význam rozmanitosti.
- Vyhodnotiť prínos agregácie stromov pre výkonnosť a stabilitu.
- Natrénovať boosting s predčasným zastavením a vysvetliť vzťah learning rate ↔ počet iterácií.
- Použiť XGBoost a LightGBM s natívnymi kategorickými príznakmi a porovnať s RandomForest.
- Zostaviť heterogénne modely (voting, stacking) a porovnať ich.
Teoretické minimum
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.
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é.
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.
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–OrdinalEncoderpre kategórie (chýbajúce/neznáme → −1), čísla bez zmeny. Stromom stačia celočíselné kódy.linear_prep– imputácia +OneHotEncoderpre kategórie,StandardScalerpre čí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']
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
| model | train_AUC | validation_AUC | validation_SD | fit_time_s |
|---|---|---|---|---|
| Decision tree | 0.9983 | 0.7631 | 0.0057 | 0.0964 |
| Bagging | 0.9972 | 0.8893 | 0.0063 | 4.8307 |
| Random forest | 0.9973 | 0.8958 | 0.0057 | 0.3903 |
- 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
- 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()train_score_ a validation_score_ ukladajú zápornú log loss (väčšie = lepšie), preto ich negujeme, aby sme dostali chybu.Výstup
| learning_rate | n_iterations | validation_AUC | fit_time_s |
|---|---|---|---|
| 0.03 | 282 | 0.9304 | 0.6851 |
| 0.10 | 133 | 0.9300 | 0.4361 |
| 0.30 | 50 | 0.9280 | 0.2213 |
| 1.00 | 25 | 0.9102 | 0.1586 |
- 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
| model | validation_AUC | validation_SD | fit_time_s |
|---|---|---|---|
| Random forest | 0.9181 | 0.0037 | 0.3694 |
| HistGradientBoosting | 0.9273 | 0.0033 | 0.7253 |
| XGBoost | 0.9274 | 0.0034 | 0.8102 |
| LightGBM | 0.9280 | 0.0033 | 0.5085 |
- 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
| model | validation_AUC | validation_SD |
|---|---|---|
| Logistic regression | 0.9053 | 0.0044 |
| Random forest | 0.9181 | 0.0037 |
| XGBoost | 0.9274 | 0.0034 |
| LightGBM | 0.9280 | 0.0033 |
| Voting (3 tree models) | 0.9279 | 0.0034 |
| Voting (all 4 models) | 0.9261 | 0.0036 |
| model | priemerná 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 |
- 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-modelu | hodnota |
|---|---|
| Logistic regression | 0.500 |
| Random forest | 2.021 |
| XGBoost | 2.269 |
| LightGBM | 2.007 |
| model | AUC | Δ vs best | folds_better |
|---|---|---|---|
| LightGBM | 0.9280 | 0.0000 | 0 |
| Voting (3 tree) | 0.9279 | −0.0001 | 2 |
| Voting (all 4) | 0.9261 | −0.0019 | 0 |
| Stacking | 0.9277 | −0.0003 | 1 |
- 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
- 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.
clonezaručuje, že trénujeme nový, nenaučený model s rovnakými hyperparametrami (nie objekt ovplyvnený predchádzajúcimi fitmi).
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)
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))Doplňujúce zdroje
- Chen & Guestrin (2016): XGBoost: A Scalable Tree Boosting System
- Ke et al. (2017): LightGBM
- Erickson et al. (2020): AutoGluon-Tabular
- Shwartz-Ziv & Armon (2021): Tabular Data: Deep Learning is Not All You Need
- Grinsztajn et al. (2022): Why do tree-based models still outperform deep learning on tabular data?
- Zadanie: pok-isi.fei.tuke.sk/04-skupinove-metody.html