LightGBM | Como funciona y consejos de ajuste

Creado: 2019-05-18 Última actualización: 2020-04-22 Tiempo de lectura: 3 min

LightGBM es una libreria de gradient boosting de Microsoft. Gracias a la aproximacion por histogramas y al crecimiento leaf-wise, acelera el entrenamiento sin perder precision en datos grandes y de alta dimension.

Incluye entrenamiento en GPU, soporte nativo de variables categoricas y aprendizaje distribuido, por lo que es habitual en Kaggle y produccion.

1. Caracteristicas principales #

Crecimiento leaf-wise: expande la hoja que mas reduce la perdida; controlar con max_depth o num_leaves.
Histogramas: agrupa valores continuos en bins (p. ej., 256) para ahorrar memoria y computo.
Reuso de gradientes/Hessian: agrega estadisticas por bin para mejorar cache.
Soporte categorico nativo: evita one-hot y busca cortes binarios optimos.
Funciones de produccion: early stopping, pesos, restricciones monotoneas, GPU.

2. Objetivo en formulas #

Como en el boosting clasico, se agregan modelos con el gradiente negativo.

$$ \mathcal{L} = \sum_{i=1}^n \ell\big(y_i, F_{m-1}(x_i) + f_m(x_i)\big) + \Omega(f_m) $$

LightGBM resume gradientes $g_i$ y Hessianos $h_i$ por bin y calcula la ganancia:

$$ \text{Gain} = \frac{1}{2} \left( \frac{\left(\sum_{i \in L} g_i\right)^2}{\sum_{i \in L} h_i + \lambda} + \frac{\left(\sum_{i \in R} g_i\right)^2}{\sum_{i \in R} h_i + \lambda} - \frac{\left(\sum_{i \in (L \cup R)} g_i\right)^2}{\sum_{i \in (L \cup R)} h_i + \lambda} \right) - \gamma $$

$\lambda$ es regularizacion L2 y $\gamma$ es la penalizacion por split.

3. Clasificacion binaria en Python #

import lightgbm as lgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score

X, y = make_classification(
    n_samples=30_000,
    n_features=40,
    n_informative=12,
    n_redundant=8,
    weights=[0.85, 0.15],
    random_state=42,
)

X_train, X_valid, y_train, y_valid = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

params = {
    "objective": "binary",
    "metric": ["binary_logloss", "auc"],
    "learning_rate": 0.05,
    "num_leaves": 31,
    "feature_fraction": 0.8,
    "bagging_fraction": 0.8,
    "bagging_freq": 5,
    "lambda_l2": 1.0,
    "min_data_in_leaf": 30,
}

train_data = lgb.Dataset(X_train, label=y_train)
valid_data = lgb.Dataset(X_valid, label=y_valid)

gbm = lgb.train(
    params,
    train_data,
    num_boost_round=1000,
    valid_sets=[train_data, valid_data],
    valid_names=["train", "valid"],
    callbacks=[lgb.early_stopping(stopping_rounds=50, verbose=True)],
)

y_pred = gbm.predict(X_valid)
print("ROC-AUC:", roc_auc_score(y_valid, y_pred))
print(classification_report(y_valid, (y_pred > 0.5).astype(int)))

El early stopping permite usar num_boost_round grande sin sobreajustar.

4. Hiperparametros clave #

Parametro	Rol / consejos
`num_leaves`	Numero de hojas; controla la capacidad. Crecer sin pasar `2 ** max_depth`.
`max_depth`	Limite de profundidad. `-1` sin limite, pero menor ayuda a generalizar.
`min_data_in_leaf` / `min_sum_hessian_in_leaf`	Minimo de muestras / Hessian por hoja. Valores altos suavizan.
`learning_rate`	Mas bajo es mas estable, pero requiere mas arboles.
`feature_fraction`	Submuestreo de features para mejorar generalizacion.
`bagging_fraction` & `bagging_freq`	Submuestreo de filas; activo si `bagging_freq > 0`.
`lambda_l1`, `lambda_l2`	Regularizacion L1/L2.
`min_gain_to_split`	Ganancia minima para dividir; evita splits ruidosos.

5. Categoricas y valores faltantes #

Pase indices o nombres a categorical_feature. No hace falta target encoding.
Los faltantes se enrutan a una rama propia; con muchos faltantes, considerar imputacion.
Restricciones monotoneas via monotone_constraints.

categorical_cols = [0, 2, 5]
train_data = lgb.Dataset(
    X_train,
    label=y_train,
    categorical_feature=categorical_cols,
)

6. Flujo de ajuste recomendado #

Base: learning_rate=0.1, num_leaves=31, feature_fraction=1.0.
Capacidad: ajustar num_leaves y min_data_in_leaf con la loss de validacion.
Aleatoriedad: feature_fraction o bagging_fraction en 0.6–0.9.
Regularizacion: lambda_l1/lambda_l2 o min_gain_to_split.
Reducir learning rate: bajar a 0.01 y subir num_boost_round.
Ensemble: combinar varios LightGBM con seeds distintas.

7. Resumen #

LightGBM usa histogramas y crecimiento leaf-wise para ser rapido y preciso.
Ajuste num_leaves y learning_rate, con regularizacion y submuestreo para generalizar.
Su soporte de categorias, faltantes y GPU lo hace fuerte en produccion y ensambles.