XGBoost: gradient boosting que dominó Kaggle y sobrevivió al hype

Esta es la parte #6 de la serie (eXtreme Gradient Boosting) es una implementación optimizada de gradient boosting. La idea base de gradient boosting no es nueva — viene de los 90s — pero XGBoost la llevó a otro nivel con una implementación que prioriza velocidad, memoria y paralelismo de forma obsesiva.

El truco conceptual de gradient boosting es elegante: entrenás un árbol de decisión, mirás dónde se equivocó, entrenás otro árbol para corregir esos errores, y repetís. Al final tenés un ensemble donde cada árbol aprende de los errores del anterior. XGBoost agrega regularización matemática al proceso (términos L1 y L2) para evitar overfitting, y hace la búsqueda de splits de forma paralela en lugar de secuencial. El resultado es que entrena más rápido y generaliza mejor que las implementaciones naive.

Soporta Python, R, Julia, Java, Scala, C++ — prácticamente cualquier stack donde puedas necesitarlo. Y tiene integración nativa con Spark, Hadoop y Dask para escalar horizontalmente sin reescribir tu código. Licencia Apache 2.0, open source, mantenido activamente por la comunidad DMLC.

import xgboost as xgb

from sklearn.model_selection import train_test_split

from sklearn.metrics import f1_score

import pandas as pd



# Cargamos datos (datos tabulares: el territorio donde XGBoost brilla)

df = pd.read_csv('churn_dataset.csv')

X = df.drop('churn', axis=1)

y = df['churn']



X_train, X_test, y_train, y_test = train_test_split(

    X, y, test_size=0.2, random_state=42

)



# Configuración básica — estos defaults ya son competitivos

modelo = xgb.XGBClassifier(

    n_estimators=300,        # cantidad de árboles en el ensemble

    max_depth=6,             # profundidad máxima de cada árbol

    learning_rate=0.1,       # cuánto "aprende" cada árbol nuevo

    subsample=0.8,           # fracción de datos por árbol (evita overfitting)

    colsample_bytree=0.8,    # fracción de features por árbol

    use_label_encoder=False,

    eval_metric='logloss',

    random_state=42

)



modelo.fit(

    X_train, y_train,

    # early stopping: para si no mejora en 50 rondas consecutivas

    early_stopping_rounds=50,

    eval_set=[(X_test, y_test)],

    verbose=False

)



y_pred = modelo.predict(X_test)

print(f"F1 Score: {f1_score(y_test, y_pred):.4f}")

Un detalle que me parece genial: el early_stopping_rounds. Le decís "si en 50 rondas no mejorás, pará". Evita que entres con 500 estimadores y termines overfitteando por no prestarle atención.

# Para datos distribuidos con Dask (escala horizontal sin cambiar lógica)

import dask.dataframe as dd

from xgboost import dask as xgb_dask

import dask.distributed



# El cliente Dask maneja el cluster — puede ser local o en la nube

cliente = dask.distributed.Client()



# XGBoost habla Dask nativamente, sin wrappers raros

X_dask = dd.from_pandas(X_train, npartitions=4)  # particionamos los datos

y_dask = dd.from_pandas(y_train, npartitions=4)



# La API es casi idéntica al caso single-node

resultado = xgb_dask.train(

    cliente,

    {"objective": "binary:logistic", "max_depth": 6, "learning_rate": 0.1},

    xgb_dask.DaskDMatrix(cliente, X_dask, y_dask),

    num_boost_round=300

)

Por qué está en la lista

XGBoost apareció en 5 awesome lists independientes. Eso es señal fuerte — cuando la comunidad de ML hace listas de "lo que realmente sirve", este nombre aparece una y otra vez. No porque esté de moda, sino porque lleva más de una década entregando resultados.

Lo que lo distingue de alternativas como Random Forest o incluso de las redes neuronales para datos tabulares es la combinación de precisión, velocidad e interpretabilidad. Podés sacarle feature importance de forma nativa — entendés qué variables están manejando las predicciones. Con una red neuronal profunda eso es bastante más complicado. Para contextos donde el modelo tiene que ser auditado (decisiones de crédito, scoring médico, churn en telco) esto importa.

Además, el soporte distribuido es real y no es un afterthought. En los posts anteriores de la serie hablamos de — esas herramientas escalan también, pero están optimizadas para tensores y redes neuronales. XGBoost escala para lo que hace: árboles sobre datos tabulares. Distintos problemas, distintas herramientas.

El análisis del sistema de curación lo clasificó como GEM — el nivel más alto. La razón es simple: es matemática sólida con implementación probada en producción real, en miles de empresas, durante años. No es hype de paper académico que nadie puso en producción. Es battle-tested en el sentido más literal de la palabra.

Cuándo NO usarlo

Si tu problema implica datos no estructurados — imágenes, audio, texto libre — XGBoost no es tu herramienta. Ahí ganás con deep learning, y suele ser más amigable out-of-the-box, aunque la diferencia en práctica es menor de lo que la gente cree. Y si tenés muchas features categóricas sin encodear, . Si te perdiste los posts anteriores, en el #3 hablé de