Cómo funciona el algoritmo XGBoost en Python

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.

¿ 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..

Cómo instalar xgboost en Python

La instalación de Xgboost es, como su nombre indica, extremadamente complicada. Es broma! Es tan sencillo como utilizar pip.

pip install xgboost

Entendiendo los parámetros de xgboost

Este algoritmo tiene muchos parámetros que podemos ir tocando para sacarle todo su potencial, pero de momento te voy a explicar los más utilizados.

• objective – La tarea para la que quieres optimizar xgboost. Aquí es donde se indica si queremos hacer regresión, clasificación binaria, etc.
• n_estimators – Número de árboles que llevan a cabo el boosting. También se entiendo como el número de iteraciones de boosting.
• eta – También conocido como ratio de aprendizaje o learning rate. Básicamente su función es reducir el tamaño de los pesos del algoritmo.

Ejemplo de implementación

La API de la librería XGBoost es muy sencilla y lleva la misma estructura que la Libreria de SKLearn con el fit() y predict(). Vamos a ver cómo 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 LogisticRegression 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 Logistic Regression: ', 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 logística 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:

• Reconocimiento de Imágenes
• Problemas de Visión por Computador
• NLP

Conclusiones

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.