Sklearn + Boosting modely

Hotové modely — nemusíš psát nic od nuly. Fit, predict, hotovo.

Základní kostra (funguje pro všechny)

import pandas as pd
from sklearn.model_selection import train_test_split

train = pd.read_csv("train.csv")
test  = pd.read_csv("test.csv")

X = train.drop(columns=["target"])
y = train["target"]

X_tr, X_val, y_tr, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

model.fit(X_tr, y_tr)
print(model.score(X_val, y_val))  # accuracy pro classifier, R² pro regressor

preds = model.predict(test)

Který model na co

Úloha	Doporučení
Tabular klasifikace	XGBoost nebo LightGBM
Tabular regrese	XGBoost nebo LightGBM
Hodně kategorických featur	CatBoost (žádný get_dummies)
Rychlý baseline	Random Forest
Obrázky	PyTorch CNN
Text	PyTorch + embeddingy / transformery
Malý dataset (<1000 vzorků)	Random Forest, SVM

Hyperparametry — co dělají a jak nastavit

n_estimators (RF, XGB, LGB) / iterations (CatBoost)

Počet stromů. Víc = lepší výkon, pomalejší trénink.

Start: 300
Dobré: 500–1000
Víc než 1000 málokdy pomůže

learning_rate (XGB, LGB, CatBoost)

Jak velký krok každý strom udělá. Menší = pomalejší ale přesnější.

Start: 0.1 (rychlý trénink)
Lepší výkon: 0.05 nebo 0.01 (potřebuješ víc stromů)
Pravidlo: menší lr → větší n_estimators

max_depth (XGB, CatBoost) / depth (CatBoost)

Hloubka každého stromu. Hlubší = model se naučí složitější vzory ale přefituje.

Start: 6
Malý dataset: 3–4
Velký dataset: 6–8
Nikdy nedávej víc než 10

num_leaves (LightGBM)

LightGBM roste do šířky místo hloubky. Ekvivalent max_depth.

num_leaves = 2^max_depth přibližně
Start: 31
Víc featur → víc listů

subsample (XGB, LGB)

% trénovacích dat použitých na každý strom. Náhodnost zabraňuje overfitu.

Rozsah: 0.5–1.0
Start: 0.8

colsample_bytree (XGB) / feature_fraction (LGB)

% featur použitých na každý strom. Stejný princip jako subsample.

Start: 0.8

min_samples_leaf (RF)

Min. počet vzorků v listu stromu. Vyšší = jednodušší strom = méně overfitu.

Start: 1 (default)
Pokud overfit: zkus 5 nebo 10

reg_alpha, reg_lambda (XGB, LGB)

L1 a L2 regularizace. Penalizuje komplexní modely.

Default: 0 (žádná regularizace)
Pokud overfit: zkus reg_lambda=1

Random Forest

from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor

model = RandomForestClassifier(
    n_estimators=500,
    max_depth=None,       # None = roste dokud může (pozor na overfit na malých datech)
    min_samples_leaf=2,
    n_jobs=-1,
    random_state=42
)

Vhodný pro: rychlý baseline, malé datasety, robustní vůči outlieram.
Strop: ~0.80 na většině Kaggle úloh. Pak přejdi na XGBoost.

XGBoost

from xgboost import XGBClassifier, XGBRegressor

model = XGBClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    n_jobs=-1,
    random_state=42,
    eval_metric="logloss"  # pro klasifikaci, "rmse" pro regresi
)

Vhodný pro: skoro všechno tabulární. Standard na Kaggle.

LightGBM

from lightgbm import LGBMClassifier, LGBMRegressor

model = LGBMClassifier(
    n_estimators=500,
    learning_rate=0.05,
    num_leaves=31,
    subsample=0.8,
    colsample_bytree=0.8,
    n_jobs=-1,
    random_state=42,
    verbose=-1   # vypne spam v terminálu
)

Vhodný pro: velká data (>100k řádků), rychlejší než XGBoost, podobný výsledek.

CatBoost

from catboost import CatBoostClassifier, CatBoostRegressor

model = CatBoostClassifier(
    iterations=500,
    learning_rate=0.05,
    depth=6,
    cat_features=["Cabin_deck", "Cabin_side"],  # seznam kategorických sloupců, žádný get_dummies!
    verbose=100,
    random_state=42
)

Vhodný pro: datasety s hodně kategorickými featury. Zpracuje je sám.

Feature importance — co modelu záleží nejvíc

feat_imp = pd.Series(model.feature_importances_, index=X.columns)
print(feat_imp.sort_values(ascending=False).head(10))

Ukazuje které featury nejvíc přispívají. Featury s importance ~0 můžeš vyhodit.

GridSearch — automatické ladění hyperparametrů

from sklearn.model_selection import GridSearchCV

params = {
    "n_estimators": [300, 500],
    "max_depth": [4, 6, 8],
    "learning_rate": [0.05, 0.1],
}
gs = GridSearchCV(XGBClassifier(), params, cv=5, scoring="accuracy", n_jobs=-1)
gs.fit(X_tr, y_tr)
print(gs.best_params_)
model = gs.best_estimator_

Zkouší všechny kombinace, cv=5 = 5-fold cross validation. Pomalé na velkých gridech.

Feature engineering — jak vylepšit dataset

Největší skok ve score pochází odsud, ne z modelu.

Rozdělení sloupců

# Cabin "B/0/P" → 3 featury
df[["Cabin_deck", "Cabin_num", "Cabin_side"]] = df["Cabin"].str.split("/", expand=True)

# ID "0001_01" → group číslo
df["Group"] = df["PassengerId"].str.split("_").str[0].astype(int)

Agregace

# Součet více sloupců
spend_cols = ["RoomService", "FoodCourt", "ShoppingMall", "Spa", "VRDeck"]
df["TotalSpend"] = df[spend_cols].sum(axis=1)

# Průměr skupiny (group-level feature)
df["GroupMeanAge"] = df.groupby("Group")["Age"].transform("mean")

Binning — číselné hodnoty → kategorie

# Věk do skupin
df["AgeGroup"] = pd.cut(df["Age"], bins=[0, 12, 18, 35, 60, 100],
                         labels=["child", "teen", "adult", "middle", "senior"])

Logaritmická transformace — pro zešikmená data (útrata, cena)

import numpy as np
df["LogSpend"] = np.log1p(df["TotalSpend"])  # log1p = log(x+1), zvládne nuly

Fillna — strategie

# Číselné: medián (robustnější než průměr na outliery)
df[num_cols] = df[num_cols].fillna(df[num_cols].median())

# Kategorické: "None" nebo nejčastější hodnota
df[cat_cols] = df[cat_cols].fillna("None")
df["HomePlanet"] = df["HomePlanet"].fillna(df["HomePlanet"].mode()[0])

StandardScaler — normalizace pro neuronové sítě

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train[num_cols] = scaler.fit_transform(X_train[num_cols])
X_test[num_cols]  = scaler.transform(X_test[num_cols])  # pozor: jen transform, ne fit!

Pro stromy (RF, XGB, CatBoost) scaler nepomůže — stromy jsou invariantní vůči škálování.

SMOTE — vyvažování nevyvážených tříd

# pip install imbalanced-learn --break-system-packages
from imblearn.over_sampling import SMOTE

sm = SMOTE(random_state=42)
X_res, y_res = sm.fit_resample(X_train, y_train)

Použij když jedna třída má výrazně méně vzorků (např. fraud detection: 1% podvodů).

Pro obrazkové úlohy (CV)

Sklearn na obrázky nestačí — použij PyTorch.

import torchvision.transforms as transforms

transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])  # ImageNet stats
])

Transfer learning — nejrychlejší cesta k dobrému CV výsledku

import torchvision.models as models

# Předtrénovaný ResNet, změní jen poslední vrstvu
model = models.resnet18(pretrained=True)
model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)  # tvůj počet tříd

Místo trénovat CNN od nuly — vezmeš model naučený na ImageNetu (1M obrázků) a doučíš ho na svých datech. Rychlejší, lepší výsledky na malých datasetech.

🌲 Sklearn & Boosting

Modely

Referenční poznámky