XGBoost – el algoritmo que lo peta en las competiciones de Kaggle

El XGBoost es uno de los algoritmos supervisados de Machine Learning que más se usan en la actualidad. Esto se debe por su facilidad de implementación, sus buenos resultados y porque está predefinido en un montón de lenguajes. En este post vamos a aprender a implementarlo en Python.

Para este post, asumo que ya tenéis conocimientos sobre los algoritmos ensamblados con boosting (si os suena a chino aquí tenéis post explicando qué es esto) y regularización.

Bagging and Boosting | Most Used Techniques of Ensemble Learning
Imagen obtenida en el este sitio web.

¿Qué es XGBoost?

El eXtreme Gradient Boost se trata de la librería/algoritmo más de moda en problemas supervisados (Aquí os dejo un link a la documentación oficial).

Este algoritmo se creó originalmente en C++. Pero con el paso del tiempo y su buenos resultados se fue desarrollando en más lenguajes de programación. Tantos que ahora mismo está ya disponible en todos los lenguajes más utilizados para análisis de datos (Python, R, Scala, Julia, Java etc).

Ya os estoy diciendo que XGBoost es la leche, pero… ¿por qué?

Se trata de un algoritmo paralelizable. Esto nos permite usar de manera óptima toda la potencia de procesado de la que disponemos hoy en día. Se pueden utilizar múltiples núcleos a la vez. Pero también permite ejecutarlo en GPUs en paralelo, o incluso en clústers de servidores. Es decir, tiene una rapidez de entrenamiento brutal. Esto hace que entrenar el modelo en datasets gigantescos no sea tanto problema como puede serlo para otro algoritmo.

Mejora el rendimiento de la gran mayoría de algoritmos que existen en casi todas las competiciones de Machine Learning. Gracias a este potente rendimiento, XGBoost ha conseguido demostrar resultados a nivel de estado de arte en una gran variedad de benchmarks de Machine Learning..

Ejemplo de implementación

La API de la librería XGBoost es muy sencilla y lleva la misma estructura que la Liberia de SKLearn con el fit() y predict(). Vamos a ver como se hace con ejemplo sencillo de Kaggle. Tenemos datos sobre diferentes vino y una columna objetivo que es la calidad. Por facilitar el problema, vamos a convertirlo en un problema de clasificación. Simplemente vamos a clasificar el vino en bueno (calidad >= 6) o malo (calidad < 6).

Para comprobar si es verdad lo que decimos de que XGBoost suele mejorar el rendimiento de los demás algoritmos, lo voy a comparar con una regresión lineal de SKLearn. Ambos con los parámetros por defecto:

import xgboost as xgb
import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression as LR
from sklearn.model_selection import train_test_split
data = pd.read_csv('/content/winequality-red.csv')
''' 
Vamos a hacer un problema de clasificacion. Asi que lo que vamos a predecir es
si el vino es de buena calidad o no. Tomaremos el 6 como umbral para decidir si
es bueno o no. 
'''
data.loc[data['quality'] < 6, 'quality'] = 0
data.loc[data['quality'] >= 6, 'quality'] = 1
# Separamos los datos en variables y target
X,y = data.iloc[:, :-1], data.iloc[:,-1]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2,
                                                    random_state=123)
clf_xgb = xgb.XGBClassifier(objective='binary:logistic', n_estimators=10,
                            seed=123)
clf_xgb.fit(X_train, y_train)
preds_xgb = clf_xgb.predict(X_test)
clf_lr = LR().fit(X_train, y_train)
accuracy_xgb = float(np.sum(preds_xgb == y_test))/y_test.shape[0]
print('Accuracy de XGBoost: ', accuracy_xgb)
accuracy_lr = clf_lr.score(X_test, y_test)
print('Accuracy de Regresion Lineal: ', accuracy_lr)

Como os llevo diciendo todo el post, XGBoost es muy potente. Aquí vemos como con este tenemos un accuracy de 67% mientras que la regresión lineal nos da un pobre 26%.

Os traigo además un paper donde analizan el algoritmo XGBoost comparándolo con otros algoritmos basados en árboles como son el RandomForest y el Gradient Boosting Machine. Analizan los hiperparámetros que se pueden tunear (psssst, te mola el tuning? Aquí puedes aprender qué es) y cómo cambia el rendimiento con ello. Si queréis mirar más este trabajo os dejo el enlace a su GitHub también.

¿Cuándo se debe usar XGBoost?

Deberías considerar probar el performance del algoritmo en cualquier problema supervisado que cumple las siguientes características:

  • Para datasets grandes (más de 1000 observaciones, esto se debe a que el boosting mejora con iteraciones) y que el número de variables sea menor que el número de observaciones.
  • Para problemas con una mezcla de variables categóricas y numéricas, o sólo numéricas (al contrario que la regresión lineal, el KNN o el K-Means, este algoritmo sí que acepta variables categóricas tal cual están).

¿Cuándo no es buena idea utilizar XGBoost?

Hay una gran variedad de problemas supervisados en los que otros algoritmos de Deep Learning son capaces de darnos mucho mejor rendimiento que el XGBoost. Entre ellos, los más destacados son:

Hoy os he explicado qué es el XGBoost y por qué es los algoritmos más de moda en la actualidad. En el siguiente post os explicaré los hiperparémetros que tiene y cómo tunearlos para conseguir el mejor rendimiento.