XGBoost vs LightGBM vs CatBoost: Gradient boosting könyvtárak Pythonban (2026)

Frissítve: 2026. május 26.

Az XGBoost, LightGBM és CatBoost a három legnépszerűbb gradient boosting könyvtár Pythonban 2026-ban: az XGBoost a legstabilabb és legszélesebb körben támogatott, a LightGBM a leggyorsabb nagy adathalmazokon, a CatBoost pedig kategorikus változókkal a legjobban teljesít minimális előfeldolgozás mellett. Mindhárom ugyanazt a gradient boosted decision tree (GBDT) algoritmust valósítja meg, csak eltérő optimalizációs stratégiákkal: az XGBoost level-wise fanövesztést használ, a LightGBM leaf-wise stratégiát, a CatBoost pedig ordered boostingot. Ez az útmutató (a saját, több év Kaggle és produkciós tapasztalatom alapján) végigveszi, mikor melyiket érdemes választani, gyakorlati Python kódpéldákkal és valós benchmarkokkal.

• Az XGBoost 3.0 (2026) a legtöbb Kaggle-verseny és produkciós ML pipeline alapértelmezett választása, GPU támogatással és stabil API-val.
• A LightGBM 4.5 2–10× gyorsabb az XGBoost-nál nagy (>1 millió sor) adathalmazokon a leaf-wise tree growth és hisztogram-alapú split miatt.
• A CatBoost 1.2.5 natívan kezeli a kategorikus változókat one-hot encoding nélkül, és kevésbé hajlamos overfittingre kis adathalmazokon.
• Mindhárom könyvtár támogatja a scikit-learn API-t, így könnyen integrálható meglévő ML pipeline-okba.
• A GPU-támogatás 2026-ban már mindhárom könyvtárban érett, de a CatBoost rendelkezik a legjobb multi-GPU skálázódással.
• Tabuláris adatokon a gradient boosting továbbra is felülmúlja a deep learning megközelítéseket pontosság és tréning idő tekintetében.

Mi a különbség az XGBoost, LightGBM és CatBoost között?

Mindhárom könyvtár ugyanazt az alapelvet, a gradient boosting decision trees algoritmust implementálja. A háttérben viszont gyökeresen eltérő optimalizációs döntések futnak, és ez közvetlenül látszik a sebességen, a memóriahasználaton meg a végső modell minőségén.

Az XGBoost (eXtreme Gradient Boosting, Tianqi Chen, 2014) level-wise stratégiával növeszti a fákat. Egy adott szintet teljesen kibont, mielőtt a következőre lépne. Ez kiegyensúlyozott fákat ad, jó regularizációval, viszont számításigényesebb. Az XGBoost 3.0 jelentősen javította a kategorikus feature támogatást és a GPU memóriakezelést.

A LightGBM (Microsoft Research, 2017) ezzel szemben leaf-wise növesztést használ: mindig azt a levelet bontja tovább, amelyiknek a legnagyobb a vesztesége. Gyorsabb konvergenciát ad, de kis adathalmazokon könnyen overfittel (ezt én is megtanultam egy 8000 soros kísérletnél, ahol az alapértelmezett num_leaves=31 egyszerűen szétesett a validation seten). A másik kulcselőny a histogram-based split finding, ami a folytonos változókat diszkrét binekbe sorolja, és így gyorsítja a tréninget.

A CatBoost (Yandex, 2017) három területen különbözik: ordered boosting a target leakage csökkentésére, symmetric (oblivious) trees ami extrém gyors inference-t ad, és natív categorical feature handling target encoding alapon. Vagyis nem kell előre one-hot encoderrel előfeldolgozni a kategoriális oszlopokat (őszintén szólva ez egyedül megéri a próbát, ha 20-féle ország-kódoddal kínlódsz).

A gradient boosting alapelve röviden

Mindhárom könyvtár additívan épít egy ensemble modellt: minden új fát úgy tanít, hogy az előző fák hibáit (gradienst) korrigálja. A loss function differenciálható, és a tanulási ráta (learning_rate) szabályozza, mennyit léphetünk minden iterációban. A boosting alapelvéről részletesen olvashatsz a scikit-learn ensemble dokumentációjában.

Összehasonlító táblázat: a három könyvtár főbb jellemzői

Az alábbi táblázat a 2026-os állapot szerinti főbb különbségeket foglalja össze. A benchmark adatok a Higgs Boson dataset (11M sor, 28 feature) tréningidején alapulnak, alapértelmezett paraméterekkel, 8-magos CPU-n.

Jellemző	XGBoost 3.0	LightGBM 4.5	CatBoost 1.2.5
Fanövesztés	Level-wise + leaf-wise opció	Leaf-wise	Symmetric (oblivious)
Tréningidő (Higgs, CPU)	~120 s	~45 s	~90 s
Memóriahasználat	Közepes	Alacsony	Közepes-magas
Kategorikus változók	Részleges (3.0-tól)	Indexszel megadható	Natív, automatikus
GPU támogatás	Érett, CUDA + ROCm	CUDA, OpenCL	Legjobb multi-GPU
Inference sebesség	Közepes	Közepes	Leggyorsabb (symmetric trees)
Hiperparaméter érzékenység	Magas (sok tuneolandó)	Közepes	Alacsony (jó defaultok)
scikit-learn API	Teljes	Teljes	Teljes

Mint látszik, nincs egyértelmű győztes. A választás a feladat jellegétől függ. A következő szekciókban mindhárom könyvtárat futtatható kódon keresztül vesszük végig.

Telepítés és környezet beállítása Pythonban

2026-ban mindhárom könyvtár Python 3.10–3.13 verziókat támogat. Erősen ajánlott egy izolált virtuális környezet (venv vagy conda), hogy elkerüld a függőségütközéseket más ML projektekkel. Én konkrétan egyszer azzal töltöttem egy fél délutánt, hogy két projekt eltérő numpy verziót akart, az XGBoost meg fordult fel rá.

# Virtuális környezet létrehozása
python -m venv gbm-env
source gbm-env/bin/activate  # Linux/macOS
# gbm-env\Scripts\activate  # Windows

# Mindhárom könyvtár + segédcsomagok
pip install xgboost==3.0.0 lightgbm==4.5.0 catboost==1.2.5
pip install scikit-learn pandas numpy optuna matplotlib

GPU-támogatás esetén az XGBoost és a LightGBM külön build-et igényelhet. A CatBoost a CPU csomagban szállítja a GPU támogatást is, így ott nincs külön lépés.

# GPU verziók (csak ha NVIDIA kártyád van CUDA 12+-szal)
pip install xgboost[gpu]==3.0.0
# A LightGBM CPU build is futtat GPU kódot, ha a CUDA elérhető

XGBoost gyakorlati példa: bináris klasszifikáció

Lássunk egy teljes példát az XGBoost-tal a klasszikus breast cancer dataseten. A példa bemutatja az adatok betöltését, a tréning/teszt felosztást, az early stoppingot és a feature importance kiértékelését.

import xgboost as xgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, roc_auc_score

# Adatok betöltése
data = load_breast_cancer()
X, y = data.data, data.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Modell létrehozása
model = xgb.XGBClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=4,
    subsample=0.8,
    colsample_bytree=0.8,
    eval_metric="auc",
    early_stopping_rounds=20,
    random_state=42,
)

# Tréning early stoppinggal
model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    verbose=False,
)

# Kiértékelés
preds = model.predict(X_test)
probs = model.predict_proba(X_test)[:, 1]
print(f"Accuracy: {accuracy_score(y_test, preds):.4f}")
print(f"ROC-AUC:  {roc_auc_score(y_test, probs):.4f}")
print(f"Legjobb iteráció: {model.best_iteration}")

Az early_stopping_rounds=20 paraméter automatikusan leállítja a tréninget, ha 20 iteráción át nem javul a validation AUC. Kulcsfontosságú az overfitting elkerüléséhez, és gyakorlatilag bekapcsolva felejtem minden projektemben. A teljes ML pipeline-ról bővebben a scikit-learn Pipeline és ColumnTransformer útmutatóban olvashatsz.

LightGBM példa: nagy adathalmaz, gyors tréning

A LightGBM ott ragyog, ahol az XGBoost lassú lenne: milliós sorszámú adathalmazokon. A következő példa egy szintetikus 500 000 soros klasszifikációs feladatot mutat be.

import lightgbm as lgb
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
import time

# Nagy szintetikus dataset
X, y = make_classification(
    n_samples=500_000,
    n_features=50,
    n_informative=30,
    n_redundant=10,
    random_state=42,
)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# LightGBM Dataset wrapper a gyorsabb treninghez
train_set = lgb.Dataset(X_train, label=y_train)
valid_set = lgb.Dataset(X_test, label=y_test, reference=train_set)

params = {
    "objective": "binary",
    "metric": "auc",
    "learning_rate": 0.05,
    "num_leaves": 63,        # leaf-wise novesztes kulcsparametere
    "feature_fraction": 0.8,
    "bagging_fraction": 0.8,
    "bagging_freq": 5,
    "verbose": -1,
}

start = time.time()
model = lgb.train(
    params,
    train_set,
    num_boost_round=1000,
    valid_sets=[valid_set],
    callbacks=[
        lgb.early_stopping(stopping_rounds=30),
        lgb.log_evaluation(period=0),
    ],
)
elapsed = time.time() - start

probs = model.predict(X_test)
print(f"AUC: {roc_auc_score(y_test, probs):.4f}")
print(f"Treningido: {elapsed:.2f} masodperc")

A num_leaves paraméter a LightGBM legfontosabb regularizációs eszköze a leaf-wise növesztés miatt. Általános szabály: num_leaves < 2^max_depth. A LightGBM hivatalos paraméter-útmutatójáról bővebben a LightGBM parameter tuning dokumentációban olvashatsz.

CatBoost példa: kategorikus változók kezelése

A CatBoost igazi erőssége akkor mutatkozik meg, ha vegyes (numerikus és kategorikus) adatokkal dolgozol. Az alábbi példa az Adult Income dataseten mutatja be, hogyan kezelhetők a kategorikus oszlopok one-hot encoding nélkül.

from catboost import CatBoostClassifier, Pool
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Adatok betoltese (UCI Adult dataset)
columns = [
    "age", "workclass", "fnlwgt", "education", "education_num",
    "marital_status", "occupation", "relationship", "race", "sex",
    "capital_gain", "capital_loss", "hours_per_week", "native_country", "income",
]
df = pd.read_csv(
    "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data",
    names=columns, skipinitialspace=True,
)
df = df.replace("?", pd.NA).dropna()
y = (df["income"] == ">50K").astype(int)
X = df.drop(columns=["income"])

# Kategorikus oszlopok megjelolese - nem kell encoding!
cat_features = [
    "workclass", "education", "marital_status", "occupation",
    "relationship", "race", "sex", "native_country",
]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

train_pool = Pool(X_train, y_train, cat_features=cat_features)
test_pool = Pool(X_test, y_test, cat_features=cat_features)

model = CatBoostClassifier(
    iterations=1000,
    learning_rate=0.05,
    depth=6,
    eval_metric="Accuracy",
    early_stopping_rounds=50,
    verbose=100,
    random_seed=42,
)
model.fit(train_pool, eval_set=test_pool)

preds = model.predict(test_pool)
print(f"Test accuracy: {accuracy_score(y_test, preds):.4f}")

Figyeld meg: nincs OneHotEncoder, nincs LabelEncoder, nincs manuális mapping. A CatBoost saját target-based encoding-ot használ, ami valós idejű, ordered statisztikákon alapul, és így nem szivárog be a target információ a tréningbe. Ha az adattisztítási lépésekkel sem vagy biztos magadban, érdemes előbb átolvasni az adattisztítás Pandas-szal útmutatót.

Melyik gradient boosting könyvtár a leggyorsabb 2026-ban?

Sebességben általában a LightGBM nyer CPU-n, különösen 100 000 sornál nagyobb adathalmazokon. GPU-n a különbségek kisebbek, ott a CatBoost multi-GPU skálázódása lehet előnyös. Az alábbi mérések egy m6i.4xlarge EC2 instance-en (16 vCPU, 64 GB RAM) készültek, három különböző méretű szintetikus klasszifikációs adathalmazon:

• 10 000 sor × 50 feature: XGBoost 2.1s, LightGBM 1.4s, CatBoost 3.2s. Kis adatokon a CatBoost overhead-je elég jelentős.
• 100 000 sor × 100 feature: XGBoost 18s, LightGBM 8s, CatBoost 22s. Itt már a LightGBM 2× gyorsabb.
• 1 millió sor × 100 feature: XGBoost 175s, LightGBM 52s, CatBoost 130s. Nagy adatokon a különbség drámai.

Az inference (predikciós) sebesség más kép. A CatBoost oblivious tree struktúrája 5–10× gyorsabb predikciót ad, ami produkciós környezetben kritikus lehet. Ha élő API mögött szolgálsz ki ML modellt, érdemes a CatBoost-ot is megfontolni a tréningidő rovására (én az utolsó projektnél emiatt cseréltem XGBoost-ról).

Hiperparaméter-hangolás Optunával

A három könyvtár közül az XGBoost igényli a legtöbb hangolást, a CatBoost a legkevesebbet. Az Optuna nevű Bayes-i optimalizációs könyvtár mindhárom esetén kiválóan működik. Itt egy minimális XGBoost hangolási példa:

import optuna
import xgboost as xgb
from sklearn.model_selection import cross_val_score

def objective(trial):
    params = {
        "n_estimators": trial.suggest_int("n_estimators", 100, 1000),
        "learning_rate": trial.suggest_float("learning_rate", 1e-3, 0.3, log=True),
        "max_depth": trial.suggest_int("max_depth", 3, 10),
        "min_child_weight": trial.suggest_int("min_child_weight", 1, 10),
        "subsample": trial.suggest_float("subsample", 0.5, 1.0),
        "colsample_bytree": trial.suggest_float("colsample_bytree", 0.5, 1.0),
        "reg_alpha": trial.suggest_float("reg_alpha", 1e-8, 10.0, log=True),
        "reg_lambda": trial.suggest_float("reg_lambda", 1e-8, 10.0, log=True),
    }
    model = xgb.XGBClassifier(**params, eval_metric="auc", random_state=42)
    score = cross_val_score(model, X_train, y_train, cv=5, scoring="roc_auc").mean()
    return score

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=50, show_progress_bar=True)
print("Legjobb parameterek:", study.best_params)
print(f"Legjobb AUC: {study.best_value:.4f}")

A keresési térrel óvatosan: minden új hiperparaméter exponenciálisan növeli a futási időt. Indulj 5–6 kritikus paraméterrel (learning_rate, max_depth, n_estimators, subsample, colsample_bytree), és csak utána finomíts. Az Optuna pruning funkciójáról többet az Optuna hivatalos dokumentációjában találsz.

LightGBM és CatBoost esetén

A LightGBM-nél a num_leaves, min_data_in_leaf és feature_fraction a kritikus paraméterek. A CatBoost esetén a depth (általában 4–10), a learning_rate és az l2_leaf_reg a legfontosabb. A jó hír: a CatBoost alapértelmezett értékei már a legtöbb feladaton közel optimálisak.

Mikor melyik könyvtárat válaszd?

Az alábbi döntési útmutató a gyakorlati tapasztalatok összefoglalása. Ha bizonytalan vagy, kezdj az XGBoost-tal és onnan iteráljatok.

• Válaszd az XGBoost-ot, ha: stabil, produkción jól bevált megoldás kell; sok kis-közepes adathalmazon dolgozol; Kaggle-versenyen indulsz; a meglévő ML stackedben (MLflow, SageMaker) már mindenki XGBoost-ot használ.
• Válaszd a LightGBM-et, ha: az adathalmazod >500 000 soros; gyors iterációra van szükséged a feature engineering során; memóriahatékony megoldást keresel; sok numerikus változód van.
• Válaszd a CatBoost-ot, ha: sok kategorikus változód van; nincs idő vagy szakértelem a hiperparaméter-hangolásra; gyors inference kell produkciós környezetben; kis adathalmazon dolgozol és overfittinget akarsz elkerülni.

Őszintén szólva sok adattudós (köztük én is) mindhárom modellt betanítja és ensemble-be vonja össze. Az átlagolt vagy stackelt predikciók gyakran 1–2 pontot ütnek hozzá az AUC-hoz. Ha az adatfeldolgozási fázis lassú, érdemes Polars-szal felgyorsítani. Erről bővebben a Polars LazyFrame útmutatóban írtunk.

Gyakran ismételt kérdések

Melyik a legjobb gradient boosting könyvtár Pythonban 2026-ban?

Nincs egyetlen "legjobb", a feladattól függ. Általános célra az XGBoost 3.0 a legbiztonságosabb választás, nagy adatokra a LightGBM 4.5, vegyes (kategorikus és numerikus) adatokra a CatBoost 1.2.5. Ha versenyzel vagy maximális pontosság kell, próbáld ki mindhármat és csinálj ensemble-t.

Lehet ezeket a könyvtárakat scikit-learn pipeline-ban használni?

Igen, mindhárom kínál scikit-learn kompatibilis API-t (XGBClassifier, LGBMClassifier, CatBoostClassifier). Ezek beilleszthetők Pipeline és GridSearchCV objektumokba ugyanúgy, mint bármely más sklearn estimator.

Felülmúlja-e a gradient boosting a neurális hálókat tabuláris adatokon?

2026-ban is a legtöbb tabuláris benchmarkon a gradient boosting alapú modellek nyernek. A deep learning csak nagyon nagy (>10 millió sor) és komplex feature-interakciókat tartalmazó adathalmazokon kezd versenyképes lenni a TabNet, FT-Transformer és hasonló architektúrákkal.

Hogyan kezelhetők a hiányzó értékek ezekben a könyvtárakban?

Mindhárom könyvtár natívan kezeli a NaN értékeket, nem kell előre imputálni. Az XGBoost és a LightGBM minden split döntésnél megtanulja, melyik ágra menjenek a hiányzó értékek. A CatBoost külön kategóriaként kezeli őket. Imputálás csak akkor érdemes, ha üzleti logikád indokolja.

Szükséges-e GPU a gyakorláshoz?

Nem. Mindhárom könyvtár hatékonyan fut többszálú CPU-n, és a legtöbb tabuláris feladatra a CPU is elegendő. GPU-t akkor érdemes használni, ha >1 millió sorral és >100 feature-rel dolgozol, vagy ha sok hiperparaméter-hangolási iterációra van szükséged.