XGBoost remains a benchmark for tabular data despite newer boosting rivals

XGBoost: the gradient boosting that dominated Kaggle and survived the hype

This is part #6 of the Awesome Curated: The Tools series, where I do deep dives into the tools that pass the filter of our automated curation system — cross-referenced signal from multiple awesome lists, AI analysis, and a human verdict on top. XGBoost showed up in 5 independent lists. Something's going right. A couple of years ago I had to build a churn prediction model for a services company. Classic tabular data: customer age, contract length, number of support calls, invoice amount, that kind of thing. No images, no free text, nothing that justified spinning up a neural network. My first pass was Random Forest and it worked reasonably well. Then someone on the team gave me that look — "did you try XGBoost?" — the one that says seriously, you haven't tried it yet. I tried it. Within half an hour of basic tuning it was beating the Random Forest by several F1 points. Not magic — it's just that XGBoost was designed exactly for that problem. And I'm not the only one saying this. For years, XGBoost was the dominant tool on Kaggle. Tabular data competition → first place uses XGBoost. Second place too. Third place, probably also. That kind of consensus isn't built with marketing — it's built by winning. And even though LightGBM and CatBoost now contest the throne, XGBoost is still the benchmark everything else gets measured against. What it does XGBoost (eXtreme Gradient Boosting) is an optimized implementation of gradient boosting. The core idea of gradient boosting isn't new — it goes back to the 90s — but XGBoost took it to another level with an implementation that obsesses over speed, memory, and parallelism. The conceptual trick behind gradient boosting is elegant: you train a decision tree, look at where it got things wrong, train another tree to correct those errors, and repeat. You end up with an ensemble where each tree learns from the mistakes of the previous one. XGBoost adds mathematical regularization to the process (L1 and L2 terms) to prevent overfitting, and it searches for splits in parallel instead of sequentially. The result is faster training and better generalization than naive implementations. It supports Python, R, Julia, Java, Scala, C++ — pretty much any stack where you might need it. And it has native integration with Spark, Hadoop, and Dask for horizontal scaling without rewriting your code. Apache 2.0 license, open source, actively maintained by the DMLC community. import xgboost as xgb from sklearn.model_selection import train_test_split from sklearn.metrics import f1_score import pandas as pd # Load data (tabular data: the territory where XGBoost shines) 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 ) # Basic config — these defaults are already competitive model = xgb.XGBClassifier( n_estimators=300, # number of trees in the ensemble max_depth=6, # maximum depth of each tree learning_rate=0.1, # how much each new tree "learns" subsample=0.8, # fraction of data per tree (prevents overfitting) colsample_bytree=0.8, # fraction of features per tree use_label_encoder=False, eval_metric='logloss', random_state=42 ) model.fit( X_train, y_train, # early stopping: halt if no improvement for 50 consecutive rounds early_stopping_rounds=50, eval_set=[(X_test, y_test)], verbose=False ) y_pred = model.predict(X_test) print(f"F1 Score: {f1_score(y_test, y_pred):.4f}") One detail I genuinely love: early_stopping_rounds. You tell it "if you don't improve for 50 rounds, stop." It keeps you from setting 500 estimators and walking away to overfit in peace while you're not paying attention. # For distributed data with Dask (horizontal scaling without changing logic) import dask.dataframe as dd from xgboost import dask as xgb_dask import dask.distributed # The Dask client manages the cluster — can be local or cloud-based client = dask.distributed.Client() # XGBoost speaks Dask natively, no weird wrappers needed X_dask = dd.from_pandas(X_train, npartitions=4) # partition the data y_dask = dd.from_pandas(y_train, npartitions=4) # The API is nearly identical to the single-node case result = xgb_dask.train( client, {"objective": "binary:logistic", "max_depth": 6, "learning_rate": 0.1}, xgb_dask.DaskDMatrix(client, X_dask, y_dask), num_boost_round=300 ) Why it's on the list XGBoost showed up in 5 independent awesome lists. That's a strong signal — when the ML community makes lists of "stuff that actually works," this name keeps coming up. Not because it's trendy, but because it's been delivering results for over a decade. What sets it apart from alternatives like Random Forest — or even neural networks for tabular data — is the combination of accuracy, speed, and interpretability. You can pull feature importance natively out of the box. You understand which variables are driving the predictions. With a deep neural network, that's a significantly harder conversation. For contexts where the model needs to be auditable — credit decisions, medical scoring, telco churn — this matters a lot. The distributed support is also real and not an afterthought. In earlier posts in this series I covered TensorFlow and PyTorch — those tools scale too, but they're optimized for tensors and neural networks. XGBoost scales for what it does: trees on tabular data. Different problems, different tools. Our curation system classified it as a GEM — the highest tier. The reason is simple: it's solid mathematics with an implementation that's been proven in real production environments, at thousands of companies, over many years. This isn't academic paper hype that nobody ever shipped. It's battle-tested in the most literal sense of the word. When NOT to use it If your problem involves unstructured data — images, audio, free text — XGBoost is not your tool. That's where deep learning wins, and PyTorch or TensorFlow are the natural choices. XGBoost has no competitive way to learn pixel representations or text embeddings. It's also not the best option if you want to iterate really fast during exploration and the tuning feels like a headache. The hyperparameters — max_depth, learning_rate, subsample, colsample_bytree, L1/L2 regularization — interact with each other in ways that require experience, or at least a solid hyperparameter search process (Optuna works really well for this). If you need something that performs reasonably well on defaults without overthinking it, LightGBM tends to be friendlier out of the box — though the practical difference is smaller than people think. And if you have a lot of unencoded categorical features, CatBoost handles them more naturally. Wrapping up XGBoost is one of those tools that existed before I made the pivot to software development, and it's still relevant today. Not because nobody has invented something abstractly better, but because for tabular data where you need precision and explainability, it's still the real benchmark. Five independent awesome lists arrived at the same conclusion independently. That means something. This is part #6 of Awesome Curated: The Tools. If you missed the earlier posts, in #3 I covered m2cgen — a tool that lets you export ML models (including XGBoost) to native code with no Python dependencies, which is ideal when you need inference in a Java or Go environment. Reading both together makes a lot of sense. The series continues — there are more tools in the pipeline. This article was originally published on juanchi.dev

2 hours ago

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

Esta es la parte #6 de la serie Awesome Curated: The Tools, donde hago deep dives en las herramientas que pasan el filtro de nuestro sistema de curación automático — señal cruzada entre múltiples awesome lists, análisis por IA y veredicto humano. XGBoost apareció en 5 listas independientes. Algo está haciendo bien. Hace un par de años tuve que armar un modelo para predecir churn en una empresa de servicios. Datos tabulares clásicos: edad del cliente, tiempo de contrato, cantidad de llamadas al soporte, monto de factura, cosas así. Nada de imágenes, nada de texto libre, nada que justificara armar una red neuronal. La primera iteración la hice con Random Forest y anduvo razonable. Pero alguien del equipo me preguntó "¿probaste XGBoost?" con esa cara de "en serio no lo probaste todavía". Lo probé. En media hora de tuning básico le ganaba al Random Forest por varios puntos de F1. No fue magia — fue que XGBoost estaba diseñado exactamente para ese problema. No lo digo yo solo. Durante años XGBoost fue la herramienta dominante en Kaggle. Competencia de datos tabulares → primer lugar usa XGBoost. Segundo lugar también. Tercero probablemente también. Ese consenso no se construye con marketing, se construye ganando. Y aunque hoy LightGBM y CatBoost le disputan el trono, XGBoost sigue siendo el punto de referencia contra el que todos se miden. Qué hace XGBoost (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 TensorFlow y PyTorch — 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 PyTorch o TensorFlow son las opciones naturales. XGBoost no tiene forma de aprender representaciones de píxeles o embeddings de texto de manera competitiva. Tampoco es la mejor opción si querés iterar muy rápido en exploración y el tuning te parece un quilombo. Los hiperparámetros — max_depth, learning_rate, subsample, colsample_bytree, regularización L1/L2 — tienen interacciones entre sí que requieren experiencia o al menos un buen proceso de hyperparameter search (Optuna funciona muy bien para esto). Si necesitás algo que funcione razonablemente bien con defaults sin pensar, LightGBM 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, CatBoost las maneja de forma más natural. Cerrando XGBoost es de esas herramientas que existían antes de que yo pivotara al desarrollo de software, y siguen siendo relevantes hoy. No porque nadie haya inventado algo mejor en abstracto, sino porque para datos tabulares con necesidad de precisión y explicabilidad, sigue siendo el benchmark real. Cinco awesome lists independientes llegaron a la misma conclusión por su cuenta. Eso vale. Esta es la parte #6 de Awesome Curated: The Tools. Si te perdiste los posts anteriores, en el #3 hablé de m2cgen — una herramienta que te permite exportar modelos de ML (incluyendo XGBoost) a código nativo sin dependencias de Python, ideal si necesitás inferencia en un entorno Java o Go. Tiene mucho sentido leer los dos juntos. La serie sigue — hay más tools en el pipeline. Este artículo fue publicado originalmente en juanchi.dev

2 hours ago