POK-ISI Lab 4¶
Files¶
Cvičenie 4 - Skupinové metódy¶
Navigation¶
- Príprava prostredia
- O čom je cvičenie
- Ciele
- Teoretické minimum
- Postup
- Doplňujúce úlohy
- Doplňujúce zdroje
Týždeň: 4 | Predpoklady:numpy, pandas, matplotlib, scikit-learn
Príprava prostredia Anchor¶
V aktivovanom virtuálnom prostredí spustite nasledujúci príkaz:
Zdrojový kód
Upozornenie pre macOS používateľov
Ak pri príkaze from lightgbm import LGBMClassifier vznikne chyba OSError: Library not loaded: @rpath/libomp.dylib, chýba knižnica libomp, ktorá poskytuje podporu OpenMP. Inštalácia balíka lightgbm cez pip túto systémovú závislosť nezabezpečuje. Nainštalujte ju pomocou Homebrew:
Ak Homebrew nemáte nainštalovaný, postupujte podľa návodu na brew.sh.
O čom je cvičenie Anchor¶
Na tabuľkových dátach často dosahujú veľmi dobré výsledky skupinové metódy ( z angl. ensemble methods), ktoré 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 predikcie a chyby. Rozmanitosť možno vytvoriť náhodným výberom dát a príznakov, postupným učením nových modelov alebo kombinovaním modelov rôznych typov.
V úvode sa oboznámite so samostatným rozhodovacím stromom a preskúmate, ako sa jeho správanie zmení pri agregácii stromov trénovaných na bootstrapových vzorkách ( z angl. bagging) a pri postupnom posilňovaní ( z angl. boosting). Následne použijete knižnice XGBoost a LightGBM. V závere vytvoríte heterogénne skupinové modely pomocou techniky hlasovania ( z angl. voting) a skladania modelov ( z angl. stacking) a ich predikčnú kvalitu porovnáte s najlepším samostatným modelom.
Ciele Anchor¶
- Vysvetliť rozdiel medzi homogénnymi a heterogénnymi skupinovými modelmi a význam rozmanitosti základných modelov.
- Vyhodnotiť prínos agregácie rozhodovacích stromov pre predikčnú výkonnosť a stabilitu modelu.
- Natrénovať model postupného posilňovania s predčasným zastavením a vysvetliť vzťah medzi rýchlosťou učenia a potrebným počtom iterácií.
- Použiť
XGBoostaLightGBMs natívnym spracovaním kategorických príznakov a porovnať ich výsledky s klasifikátoromRandomForestClassifier. - Zostaviť heterogénne modely pomocou prístupov hlasovania a skladania modelov a porovnať ich.
Teoretické minimum Anchor¶
Skupinový model kombinuje predikcie viacerých základných modelov ( z angl. base models). Skupinové metódy môžeme rozlišovať podľa toho, aké modely kombinujú a ako ich učia a kombinujú.
Homogénne a heterogénne skupinové modely - homogénny skupinový model využíva základné modely rovnakého typu, napríklad rozhodovacie stromy. Heterogénny skupinový model kombinuje modely rôznych typov, napríklad stromový a lineárny model. Aby ich kombinovanie pomáhalo, základné modely by mali robiť aspoň čiastočne odlišné chyby. To sa dá dosiahnuť rôznymi spôsobmi učenia aj použitím rôznych typov modelov; samotná heterogenita to však nezaručuje.
Agregácia cez bootstrap (z angl. bagging) - základné modely sa učia nezávisle, každý na vlastnej bootstrapovej vzorke trénovacích dát. Tá vzniká náhodným výberom pozorovaní s opakovaním. Pri regresii sa predikcie modelov zvyčajne priemerujú, pri klasifikácii sa môže použiť väčšinové hlasovanie alebo priemerovanie predikovaných pravdepodobností, ktoré používa scikit-learn. Agregácia cez bootstrap pomáha znižovať rozptyl, najmä pri nestabilných modeloch, ako sú hlboké rozhodovacie stromy. Náhodný les navyše pri každom delení uzla zvažuje iba náhodnú podmnožinu príznakov, čím znižuje podobnosť stromov.
Postupné posilňovanie (z angl. boosting) - základné modely sa učia postupne, pričom každý ďalší model sa pri trénovaní zameriava na chyby doterajšieho skupinového modelu. Často sa používajú jednoduché rozhodovacie stromy. Pri gradientovom posilňovaní sa príspevok nového stromu upravuje rýchlosťou učenia ( z angl. learning rate). Postupné posilňovanie môže znižovať vychýlenie, pri nevhodnom nastavení sa však môže pretrénovať. Jedným zo spôsobov, ako tomu predchádzať, je použitie mechanizmu predčasného zastavenia ( z angl. early stopping).
Hlasovanie a skladanie modelov (z angl. voting and stacking) - tieto postupy sa často používajú pri heterogénnych modeloch, možno ich však použiť aj pri homogénnych. Pri väčšinovom hlasovaní ( z angl. hard voting) rozhoduje väčšina predikovaných tried. Pri priemerovaní pravdepodobností ( z angl. soft voting) sa spriemerujú pravdepodobnosti tried predikované základnými modelmi. Modely môžu mať rovnaké alebo vopred určené váhy. V tomto cvičení používame priemerovanie pravdepodobností s rovnakými váhami.
Pri technike skladania modelov tvoria predikcie základných modelov vstup ďalšieho modelu, meta-modelu, ktorý sa učí, ako ich skombinovať. Pri jeho trénovaní sa spravidla používajú predikcie získané krížovou validáciou, aby sa neučil z predikcií základných modelov na dátach, na ktorých boli trénované.
Dátová sada
Na tomto cvičení budeme pracovať s dátovou sadou Adult Income, ktorá obsahuje 48 842 záznamov zo sčítania obyvateľov USA z roku 1994. Úlohou je predikovať, či ročný príjem osoby presahuje 50 000 USD. Ide o binárnu klasifikáciu s nevyváženými triedami, pozitívnu triedu tvorí približne 24% záznamov.
Dátová sada kombinuje číselné príznaky (vek, počet rokov vzdelávania, kapitálové zisky a straty, počet odpracovaných hodín týždenne) s kategorickými (typ zamestnávateľa, rodinný stav, povolanie, krajina pôvodu a ďalšie). Tri kategorické príznaky obsahujú chýbajúce hodnoty. Práve na takýchto zmiešaných tabuľkových dátach dosahujú skupinové metódy založené na stromoch dlhodobo veľmi dobré výsledky.
Postup Anchor¶
Nasledujúci kód načíta dáta, rozdelí ich na trénovaciu a testovaciu množinu a pripraví dva postupy predspracovania, konkrétne tree_prep pre stromové modely a linear_prep pre lineárny model. Oba sa v ďalších úlohách použijú ako prvý krok v Pipeline, takže sa vždy učia iba z trénovacej časti dát.
Zdrojový kód
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}")
Poznámka
Modely v tomto cvičení porovnávame pomocou metriky roc_auc_score a identického rozdelenia trénovacej množiny do piatich foldov. Úlohy 1.2 a 2.1 skúmajú priebeh učenia jedného modelu, preto používajú jedno rozdelenie trénovacej množiny na trénovacie a validačné dáta. Samotnú testovaciu množinu použijeme iba raz, konkrétne v Úlohe 5.1.
Krok 1: Agregácia cez bootstrap - bagging Anchor¶
V tomto kroku overíte, ako agregácia cez bootstrap a náhodný les menia správanie plne rozvinutého rozhodovacieho stromu. Najprv porovnáte trénovaciu a validačnú hodnotu metriky roc_auc_score samostatného stromu a oboch homogénnych skupinových modelov, potom budete sledovať, ako sa predikcia náhodného lesa mení s počtom stromov.
Úloha 1.1 - Od jedného stromu k náhodnému lesu Anchor¶
Porovnajte DecisionTreeClassifier bez obmedzenia maximálnej hĺbky s dvoma skupinovými modelmi, konkrétne BaggingClassifier so 100 rozhodovacími stromami a RandomForestClassifier taktiež so 100 stromami.
Každý klasifikátor vložte do reťazca spracovania s krokom tree_prep pred modelom. Na trénovacej množine ich vyhodnoťte pomocou zhodnej päťnásobnej krížovej validácie, pričom krok tree_prep sa v každom folde prispôsobí iba jeho trénovacej časti. Pre každý model uveďte priemernú trénovaciu a validačnú hodnotu metriky roc_auc_score s prislúchajúcou hodnotou smerodajnej odchýlky.
Doplňte miesta označené TODO v pripravenej kostre zdrojového kódu uvedeného nižšie.
Zdrojový kód
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" ...
# "Random forest" ..
}
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 = ...
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))
Porovnajte trénovaciu a validačnú hodnotu metriky roc_auc_score všetkých troch natrénovaných modelov. Všimnite si, pri ktorom modeli je rozdiel medzi nimi najväčší a ako sa po agregácii mení validačná hodnota metriky roc_auc_score. Čo tieto výsledky naznačujú o schopnosti modelov zovšeobecňovať pri použití nových dát? Svoje pozorovania prediskutujeme na cvičení.
Poznámka
Plne rozvinutý strom predikuje pre väčšinu pozorovaní iba pravdepodobnosť 0 alebo 1. Metrika roc_auc_score hodnotí poradie predikcií, preto takýto model penalizuje výraznejšie ako napríklad accuracy_score. Rozdiel medzi samostatným stromom a skupinovými modelmi je tak pri použití metriky roc_auc_score výrazne väčší než pri metrike accuracy_score.
Dokumentácia: DecisionTreeClassifier, BaggingClassifier, RandomForestClassifier, cross_validate
Úloha 1.2 - Ako vzniká predikcia náhodného lesa Anchor¶
V predchádzajúcej úlohe ste porovnali samostatný DecisionTreeClassifier s klasifikátorom RandomForestClassifier. Teraz preskúmate, ako sa mení predikčná kvalita klasifikátora RandomForestClassifier pri postupnom pridávaní ďalších stromov. Natrénovaný model sprístupňuje jednotlivé stromy v atribúte estimators_.
Pripravený kód rozdelí trénovaciu množinu na trénovacie dáta (X_fit) a validačné dáta (X_val), následne natrénuje model prostredníctvom RandomForestClassifier s 200 stromami. Na validačnej časti vypočítajte pravdepodobnosť pozitívnej triedy predikovanú každým stromom. Z týchto predikcií potom vytvorte priebežný priemer pre prvých k stromov a sledujte, ako sa s rastúcim k mení validačná hodnota metriky roc_auc_score. Pri samostatnom vyhodnocovaní stromov použite validačné dáta spracované natrénovaným krokom tree_prep.
Doplňte miesta označené TODO v pripravenej kostre zdrojového kódu uvedeného nižšie.
Zdrojový kód
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 = ...
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 = ...
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()
Uvedený kód vypíše hodnotu metriky roc_auc_score jednotlivých stromov a celého lesa, priemernú koreláciu medzi predikciami dvoch stromov ako mieru ich rozmanitosti a porovná hodnotu metriky accuracy_score odhadnutú na pozorovaniach mimo bootstrapovej vzorky ( z angl. out-of-bag) s jej hodnotou na validačných dátach. V grafe porovnajte roc_auc_score jednotlivých stromov s roc_auc_score lesa a určite, pri akom počte stromov sa zlepšovanie prakticky zastaví.
Poznámka
Každý strom sa učí na bootstrapovej vzorke, do ktorej sa približne tretina trénovacích pozorovaní nedostane. Na nich možno strom vyhodnotiť bez samostatnej validačnej množiny. Odhad mimo bootstrapovej vzorky je preto pri agregácii cez bootstrap dostupný takmer zadarmo.
Dokumentácia: RandomForestClassifier, roc_auc_score
Krok 2: Postupné posilňovanie - Boosting Anchor¶
V tomto kroku natrénujete model postupného posilňovania a budete sledovať, ako rýchlosť učenia ovplyvňuje počet pridaných stromov a priebeh validačnej chyby. Hyperparameter learning_rate určuje veľkosť príspevku nového stromu, zatiaľ čo hyperparameter max_iter určuje, koľko stromov sa do modelu najviac pridá. Mechanizmus predčasného zastavenia ukončí trénovanie modelu v momente, keď sa výsledok na vyhradenej validačnej časti prestane zlepšovať.
Úloha 2.1 - Rýchlosť učenia a predčasné zastavenie Anchor¶
Na dátach X_fit, y_fit z Úlohy 1.2 natrénujte klasifikátor HistGradientBoostingClassifier s hodnotami hyperparametra learning_rate = [0.03, 0.1, 0.3, 1.0]. Pre každý model nastavte hyperparameter max_iter=1000 a zároveň aktivujte mechanizmus predčasného zastavenia. Na pozorovanie stratovej funkcie ( z angl. loss function) vyčleňte 20% dát z trénovacej množiny X_fit a ukončite proces učenia, ak sa výsledok nezlepší počas 20 za sebou nasledujúcich iterácií.
Nastavením categorical_features="from_dtype" umožníte algoritmu priamo spracovať kategorické príznaky. Tieto príznaky musia mať v dátovom rámci kategorický dátový typ.
Doplňte miesta označené TODO v pripravenej kostre zdrojového kódu uvedeného nižšie.
Zdrojový kód
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 = ...
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] = ...
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()
Uvedený kód pre každú hodnotu hyperparametra learning_rate vypíše počet vykonaných iterácií, validačnú hodnotu metriky roc_auc_score, čas učenia a vykreslí priebeh trénovacej a validačnej chyby po každom pridanom strome. Porovnajte, ako sa s rastúcou rýchlosťou učenia mení počet iterácií do zastavenia a dosiahnutá validačná roc_auc_score. Aký je vzťah medzi rýchlosťou učenia a potrebným počtom iterácií a čo sa deje s validačnou chybou pri najvyššej rýchlosti učenia? Svoje pozorovania prediskutujeme na cvičení.
Dokumentácia: HistGradientBoostingClassifier
Krok 3: Ďalšie implementácie gradientového posilňovania stromov Anchor¶
XGBoost a LightGBM sú široko používané knižnice na gradientové posilňovanie rozhodovacích stromov pri práci s tabuľkovými dátami. V nastaveniach použitých v tomto cvičení vyhľadávajú vhodné rozdelenia pomocou histogramov. Podporujú tiež regularizáciu a prácu s kategorickými príznakmi a chýbajúcimi hodnotami. HistGradientBoostingClassifier z predchádzajúceho kroku je ďalšou implementáciou gradientového posilňovania stromov s histogramovým vyhľadávaním rozdelení.
Úloha 3.1 - Porovnanie XGBoost a LightGBM Anchor¶
Porovnajte klasifikátor RandomForestClassifier s tromi implementáciami gradientového posilňovania - HistGradientBoostingClassifier, XGBClassifier a LGBMClassifier. V prípade klasifikátora RandomForestClassifier tentoraz nastavte hodnotu hyperparametra min_samples_leaf=5, ktorá zabezpečí vytváranie listov s najmenej piatimi trénovacími pozorovaniami, čo zabraňuje stromom zapamätať si jednotlivé pozorovania, takže vytvorený model je primeranejším súperom než plne rozvinuté stromy z Úlohy 1.1. Všetkým trom modelom postupného posilňovania nastavte hodnotu hyperparametra learning_rate=0.1 a 300 iterácií bez aktivácie mechanizmu predčasného zastavenia. Počet iterácií sa pri HistGradientBoostingClassifier nastavuje hyperparametrom max_iter=300, pri XGBClassifier a LGBMClassifier hyperparametrom n_estimators=300. Pri klasifikátore XGBoost použite tree_method="hist" a enable_categorical=True. S týmto nastavením rozpozná XGBoost kategorické príznaky podľa dátového typu stĺpcov, LightGBM ich z takýchto stĺpcov načíta automaticky.
Vytvorené klasifikačné modely vyhodnoťte pomocou päťnásobnej krížovej validácie za použitia rovnakého rozdelenia dát do jednotlivých foldov. Porovnajte priemernú validačnú hodnotu metriky roc_auc_score a priemerný čas učenia na fold. Pri trénovaní modelu prostredníctvom RandomForestClassifier merajte čas celého reťazca vrátane predspracovania.
Doplňte miesta označené TODO v pripravenej kostre zdrojového kódu uvedeného nižšie.
Zdrojový kód
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":
}
rows = []
for name, model in boosting.items():
# TODO 2: add 5-fold CV on the folds cv with scoring="roc_auc"
scores = ...
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))
Rozdiely priemernej validačnej hodnoty metriky roc_auc_score medzi modelmi porovnajte so smerodajnou odchýlkou medzi foldmi (stĺpec validation_SD). Pri ktorých modeloch je rozdiel väčší než táto variabilita a možno z výsledkov určiť poradie troch implementácií postupného posilňovania? Svoje pozorovania prediskutujeme na cvičení.
Poznámka
Všetky štyri modely používajú neladené nastavenia. V praxi o výbere knižnice často rozhoduje rýchlosť učenia, pamäťová náročnosť a podpora konkrétnych typov dát.
Dokumentácia: XGBClassifier, LGBMClassifier
Krok 4: Heterogénne skupinové metódy Anchor¶
Doteraz ste pracovali so skupinovými metódami založenými na rozhodovacích stromoch, čo reprezentovalo homogénne skupinové metódy. V tomto kroku k modelom vytvoreným prostredníctvom RandomForestClassifier, XGBoost a LightGBM pridáte LogisticRegression ako lineárny model. Pridanie lineárneho modelu vytvára heterogénnu kombináciu. Preskúmate podobnosť ich predikcií a porovnáte dva spôsoby kombinovania rôznych modelov, konkrétne hlasovanie priemerovaním pravdepodobností a skladanie modelov.
Úloha 4.1 - Rozmanitosť predikcií a hlasovanie Anchor¶
Pomocou cross_val_predict získajte pre každý zo štyroch základných modelov pravdepodobnosti pozitívnej triedy. Použite rovnaké rozdelenie na validačné foldy ako v predchádzajúcich úlohách. Prístupy RandomForestClassifier a LogisticRegression majú predspracovanie dát zahrnuté priamo v Pipeline, zatiaľ čo XGBoost a LightGBM pracujú s kategorickými príznakmi priamo.
Z týchto základných modelov potom vytvorte dve kombinácie:
- hlasovanie troch stromových modelov,
- hlasovanie všetkých štyroch modelov.
Obe kombinácie zostavte pomocou VotingClassifier s nastavením voting="soft", teda ako hlasovanie priemerovaním pravdepodobností. Pri trénovaní VotingClassifier natrénuje všetky svoje základné modely, pri predikcii spriemeruje ich pravdepodobnosti, pričom každý model má rovnakú váhu. Oba klasifikátory uložte do slovníka voting_models a vyhodnoťte ich krížovou validáciou na rovnakých foldoch ako základné modely.
Hodnoty metriky roc_auc_score základných modelov porovnajte s hodnotami oboch kombinácií. Hodnotu metriky určite pre každý validačný fold osobitne a pri každom modeli aj kombinácii uveďte priemer hodnôt zo všetkých foldov.
Podobnosť základných modelov napokon preskúmajte pomocou matice Spearmanových korelácií ich predikovaných pravdepodobností.
Doplňte miesta označené TODO v pripravenej kostre zdrojového kódu uvedeného nižšie.
Zdrojový kód
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: ...
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)": ...,
"Voting (all 4 models)": ...,
}
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 = ...
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 = ...
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()
Na základe matice Spearmanových korelácií určte dvojicu modelov s najpodobnejšími predikciami. Ktorý model má v priemere najnižšiu koreláciu predikcií s ostatnými tromi? Porovnajte priemerné hodnoty metriky roc_auc_score oboch variantov hlasovania s priemerným roc_auc_score najlepšieho základného modelu. Zlepšilo pridanie logistickej regresie k trom stromovým modelom priemerné roc_auc_score hlasovania? Svoje pozorovania prediskutujeme na cvičení.
Dokumentácia: cross_val_predict, VotingClassifier
Úloha 4.2 - Skladanie modelov Anchor¶
Hlasovanie dáva každému modelu rovnakú váhu. Slabší model preto môže priemer zhoršiť, ak jeho odlišnosť neprináša dostatok novej informácie. Pri skladaní modelov sa váhy základných modelov učia z dát.
Pomocou StackingClassifier skombinujte rovnaké štyri základné modely ako v Úlohe 4.1. Ako meta-model použite ďalšiu, samostatnú logistickú regresiu. Jej vstupmi budú pravdepodobnosti pozitívnej triedy predikované základnými modelmi, pričom pôvodné príznaky do meta-modelu nepridávajte.
Pre učenie meta-modelu nastavte päťnásobnú vnútornú krížovú validáciu. StackingClassifier pomocou nej získa predikcie základných modelov pre trénovacie pozorovania tak, aby žiadny základný model nepredikoval pozorovanie, na ktorom sa trénoval. Celý postup následne vyhodnoťte päťnásobnou vonkajšou krížovou validáciou na rovnakých foldoch cv, aké ste použili pri hodnotení ostatných modelov.
Doplňte miesta označené TODO v pripravenej kostre zdrojového kódu uvedenej nižšie.
Zdrojový kód
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 = ...
# TODO 2: outer 5-fold CV on the folds cv with scoring="roc_auc" and return_estimator=True
stack_scores = ...
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())
Porovnajte koeficienty meta-modelu s výsledkami metriky roc_auc_score a s koreláciami predikcií základných modelov z Úlohy 4.1. Čo vaše výsledky naznačujú o prínose výkonnosti jednotlivých modelov a rozmanitosti ich predikcií pri kombinovaní? Pri interpretácii koeficientov zohľadnite, že predikcie základných modelov môžu byť silne korelované. V tabuľke combination_results si všimnite aj stĺpec folds_better, ktorý udáva počet foldov, v ktorých kombinácia prekonala najlepší základný model. Je rozdiel oproti najlepšiemu základnému modelu pri niektorej kombinácii konzistentný vo všetkých foldoch? Svoje pozorovania prediskutujeme na cvičení.
Dokumentácia: StackingClassifier
Krok 5: Záverečné vyhodnotenie Anchor¶
Všetky doterajšie rozhodnutia vychádzali z krížovej validácie na trénovacej množine. Na základe jej výsledkov teraz vyberiete výsledný postup. Odloženú testovaciu množinu použijete až po výbere na jediné záverečné vyhodnotenie.
Úloha 5.1 - Výber postupu a vyhodnotenie na testovacích dátach Anchor¶
Z tabuľky combination_results, ktorá obsahuje najlepší základný model a všetky hodnotené kombinácie, vyberte postup s najvyššou priemernou validačnou hodnotou metriky roc_auc_score. Zvolený postup natrénujte na celej trénovacej množine. Potom pomocou predikovaných pravdepodobností pozitívnej triedy vypočítajte hodnotu metriky roc_auc_score na odloženej testovacej množine.
Kandidátmi sú najlepší základný model, oba varianty hlasovania zo slovníka voting_models z Úlohy 4.1 a skladanie modelov z Úlohy 4.2. Pripravený je tak každý postup z tabuľky combination_results bez ohľadu na to, ktorý z nich krížová validácia vyberie.
Doplňte miesta označené TODO v pripravenej kostre zdrojového kódu uvedenej nižšie.
Zdrojový kód
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 = ...
# TODO 2: probabilities of the positive class for X_test and the test AUC
test_proba = ...
test_auc = ...
print(f"\nTest AUC: {test_auc:.4f}")
print(f"Difference test - CV AUC: {test_auc - cv_auc:+.4f}")
Výsledok testu je konečný
Po zobrazení testovej hodnoty metriky roc_auc_score už podľa nej nemeňte výber postupu ani nastavenia modelov. Testovacia množina slúži iba na záverečné vyhodnotenie postupu vybraného na základe krížovej validácie.
Dokumentácia: VotingClassifier, roc_auc_score
Doplňujúce úlohy 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í.
- Pomocou
RandomizedSearchCVnalaďte model LightGBM. Prehľadajte počet listov (num_leaves), rýchlosť učenia, podiel riadkov a stĺpcov použitých na jeden strom (subsample,colsample_bytree) a siluL2regularizácie (reg_lambda). Najlepšiu konfiguráciu porovnajte s nastavením z Úlohy 3.1 pomocou párových rozdielov metrikyroc_auc_scorena rovnakých foldoch. - To isté ladenie zopakujte pomocou knižnice Optuna s rovnakým počtom vyhodnotených konfigurácií. Porovnajte najlepšiu dosiahnutú validačnú hodnotu metriky
roc_auc_scores náhodným prehľadávaním a posúďte, či je rozdiel konzistentný naprieč foldmi. - Pridajte medzi základné modely CatBoost, ktorý kategorické príznaky kóduje vlastným spôsobom. Vypočítajte koreláciu jeho predikcií s modelmi XGBoost a LightGBM a overte, či sa po jeho pridaní zmenia koeficienty meta-modelu a validačná hodnota metriky
roc_auc_scorez Úlohy 4.2.
Doplňujúce zdroje Anchor¶
- Chen, T., & Guestrin, C. (2016). XGBoost: A Scalable Tree Boosting System.
- Ke, G. et al. (2017). LightGBM: A Highly Efficient Gradient Boosting Decision Tree.
- Erickson, N. et al. (2020). AutoGluon-Tabular: Robust and Accurate AutoML for Structured Data.
- Shwartz-Ziv, R., & Armon, A. (2021). Tabular Data: Deep Learning is Not All You Need.
- Grinsztajn, L., Oyallon, E., & Varoquaux, G. (2022). Why do tree-based models still outperform deep learning on tabular data?