Light GBM vs XGBoost . ¿Cuál es mejor el algoritmo ?

Consultores estratégicos en Ciencia de Datos

Light GBM vs XGBoost . ¿Cuál es mejor el algoritmo ?

En el presente artículo estableceremos una comparación entre 2 algoritmos estrella : Light GBM y XGBoost

Introducción

Ssi eres un miembro activo de la Comunidad de Machine learning de seguro estarás en contacto con los nuevos algoritmos de ensamble y los nuevos agoritmosdel llamado Machine Learning Moderno:   . El desarrollo de los algoritmos de ensamble comienza desde el Ada Boost  hasta el XGBOOST, el cual es el  favorito de hoy. XGBOOST se ha convertido en un algoritmo que gana todos los concursos de Analytics Vidhya y de Kaggle, simplemente porque es extremadamente poderoso. Pero la opinión general es que cuando hay  muchos datos, XGBOOST tarda mucho en entrenarse. Light GBM vs XGBoost ¿Cuál es mejor algoritmo ?

Hasta que aparece Light  GBM

Es posible que muchos de ustedes no estén familiarizados con Light Gradient Boost, pero lo estarán después de leer este post. La pregunta más natural que le vendrá a la mente es: ¿Por qué otro algoritmo de ensamble ? ¿Es superior a XGBOOST?

Trataremos de ver paso a paso el rendimiento y comparaciones entre ambos algoritmos para que ustedes formen su propia opinión al respecto.

 

Tabla de contenido:  Light GBM vs XGBoost ¿Cuál es mejor algoritmo ?

  1. ¿Qué es Light GBM?
  2. Ventajas de Light GBM
  3. Instalación de Light GBM
  4. Parámetros importantes de Light GBM
  5. Light GBM frente a XGBOOST
  6. Parámetros de ajuste de Light GBM
  7. Notas finales

 

1. ¿Qué es Light GBM?

Light GBM es un algoritmo de los llamados de  gradiente rápido, altamente distribuido y de alto rendimiento, originalmente  basado en un árbol de decisiones, que se utiliza principalmente para clasificar,  y muchas otras tareas de aprendizaje automático.

Dado que se basa en algoritmos de árbol de decisión, divide las hoja del árbol con «el mejor ajuste», mientras que otros algoritmos de «boosting» que dividen el árbol de acuerdo a su niveles de profundidad en  lugar de hoja por hoja a. Por lo tanto, cuando Light GBM trabaja en la misma hoja puede reducir más pérdidas que los algoritmos por niveles, dando  como resultado una mejor  precisión  que rara vez se puede lograr con los  algoritmos de refuerzo existentes. Además, es sorprendentemente muy rápido, de ahí la palabra ‘Light’.

Antes hay una representación esquemática de los creadores de Light GBM para explicar claramente la diferencia.

 Cómo funciona XGBOOST.

Cómo funciona Light GBM

 

Las divisiones por hojas conducen a un aumento de la complejidad y pueden conducir a «overfitting» y esto se podría evitar  especificando otro parámetro que especifica la profundidad a la que se producirá la división de cada hoja.

A continuación, veremos los pasos para instalar Light GBM y como usarlo. Compararemos los resultados con los resultados de XGBOOST y mostrar sus ventajas

 

2. Ventajas de Light GBM

  1. Velocidad de entrenamiento más rápida y mayor eficiencia : Light GBM utiliza un algoritmo basado en histogramas, es decir, agrupa valores de características continuos en bina o contenedores separados, lo que termina acelerando el procedimiento de entrenamiento.
  2. Menor uso de memoria: reemplaza los valores continuos por contenedores discretos, lo que da como resultado un menor uso de memoria.
  3. Mejor precisión que cualquier otro algoritmo de refuerzo: produce árboles mucho más complejos siguiendo un enfoque de división por hojas en lugar de un enfoque por niveles, que es el factor principal para lograr una mayor precisión. Sin embargo, a veces puede dar lugar a un «overtfitting» que se puede evitar configurando el parámetro max_depth.
  4. Compatibilidad con grandes conjuntos de datos: es capaz de funcionar igual de bien con grandes conjuntos de datos con una reducción significativa en el tiempo de entrenamiento en comparación con XGBOOST.
  5. Admite el aprendizaje paralelo.

Supongo que debe haberse entusiasmado con las ventajas de Light GBM.  Par poder establecer una mejor comparaciòn entre  Light GBM vs XGBoost . ¿Cuál es mejor algoritmo ? Procedamos ahora a instalar la biblioteca en nuestro sistema.

 

3. Instalación de Light GBM

  1. Para Windows

    Uso de Visual Studio (o MSBuild)
    : instale  git para Windows ,  cmake  y  MS Build  (no necesita MSbuild si ya instaló  Visual Studio ).
    -Ejecutar el siguiente comando:

    git clone --recursive https://github.com/Microsoft/LightGBM
    cd LightGBM
    mkdir build
    cd build
    cmake -DCMAKE_GENERATOR_PLATFORM=x64 ..
    cmake --build . --target ALL_BUILD --config Release
    
    

    El exe y el dll estarán en la carpeta LightGBM/Release.

     

    Usando MinGW64
    Instale git  para windows ,  cmake  y MinGW64.
    -Ejecutar el siguiente comando:

    git clone --recursive https://github.com/Microsoft/LightGBM
    cd LightGBM
    mkdir build
    cd build
    cmake -G "MinGW Makefiles" ..
    mingw32-make.exe -j4

    El exe y el dll estarán en la carpeta LightGBM/.

  2. para linux

    Light GBM usa  cmake  para instalaras . Haga lo siguiente:

    git clone --recursive https://github.com/Microsoft/LightGBM
    cd LightGBM
    mkdir build
    cd build
    cmake ..
    make -j4

     

  3. Para OSX

LightGBM depende de OpenMP para la compilación, que no es compatible con Apple Clang. Utilice gcc/g++ en su lugar.
-Ejecutar lo siguiente:

brew install cmake
brew install gcc --without-multilib
git clone --recursive https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir build 
cd build
cmake ..
make -j4

ahora vamos a hablar un poco sobre los distintos hiper parámetros que deben configurarse con Light GBM

 

4. Parámetros importantes de Light GBM

  • task : default value = train ; options = train , prediction ; con este parámetro especificamos cuál es la tarea que queremos realizar si es un entrenamiento o si es una predicción.
  • application: default=regression, type=enum, options= options :
    • regression : ejecute tareas de regresión
    • binary : clasificación binaria
    • multiclass: clasificación multi clase
    • lambdarank : aplicaciones tipo Lambdarank
  • data: type=string; training data , LightGBM se entrenará con estos datos
  • num_iterations: number of boosting iterations to be performed ; default=100; type=int
  • num_leaves : number of leaves in one tree ; default = 31 ; type =int
  • device : default= cpu ; options = gpu,cpu. dispositivo con el cual se entrenará a nuestro modelo escoja GPU para un entrenamiento más veloz
  • max_depth: S especifique la máxima profundidad sobre el cual el árbol crecerá este parámetro será utilizado para evitar y jugar con el overfitting
  • min_data_in_leaf:  mínimo número de datos en una hoja
  • feature_fraction: default=1 ; especifica la fracción de las variables que serán utilizadas para cada interacción
  • bagging_fraction: default=1 ;  especifica la fracción de las variables que serán utilizadas para cada interacción y que generalmente serán utilizadas para aumentar la velocidad del entrenamiento y evitar el overfitting
  • in_gain_to_split: default=.1 ; ganancia mínima antes de hacer una división
  • max_bin : máximo número de contenedores para almacenar las variables
  • min_data_in_bin : mínimo número de datos por cada contenedor
  • num_threads: default=OpenMP_default, type=int ; número de threads para Light GBM
  • label : type=string ; especifica la etiqueta de la columna
  • categorical_feature : type=string ; especifica las variables categóricas que serán utilizadas para entrenar nuestro modelo
  • num_class: default=1 ; type=int ; esto solamente se utiliza para la clasificación multi clase

 

5. LightGBM vs XGBoost

Así que ahora comparemos LightGBM con las técnicas de aprendizaje de conjuntos XGBoost aplicando ambos algoritmos a un conjunto de datos y luego comparando el rendimiento.

Aquí estamos utilizando un conjunto de datos que contiene información sobre personas de varios países. Nuestro objetivo es predecir si una persona gana <=50k o >50k anualmente en base a la otra información disponible. El conjunto de datos consta de 32561 observaciones y 14 características que describen a los individuos.

Aquí está el enlace al conjunto de datos: http://archive.ics.uci.edu/ml/datasets/Adult .

Les recomiendo que revisen este data set para tener una mejor percepción sobre las variables predictor as y a la vez que se pueda comprender mejor el código que describo a continuación con el fin de comparar  Light GBM vs XGBoost ¿Cuál es mejor algoritmo ?

#importing standard libraries 
import numpy as np 
import pandas as pd 
from pandas import Series, DataFrame 

#import lightgbm and xgboost 
import lightgbm as lgb 
import xgboost as xgb 

#loading our training dataset 'adult.csv' with name 'data' using pandas 
data=pd.read_csv('adult.csv',header=None) 

#Assigning names to the columns 
data.columns=['age','workclass','fnlwgt','education','education-num','marital_Status','occupation','relationship','race','sex','capital_gain','capital_loss','hours_per_week','native_country','Income'] 

#glimpse of the dataset 
data.head() 

# Label Encoding our target variable 
from sklearn.preprocessing import LabelEncoder,OneHotEncoder
l=LabelEncoder() 
l.fit(data.Income) 

l.classes_ 
data.Income=Series(l.transform(data.Income))  #label encoding our target variable 
data.Income.value_counts() 

 

#One Hot Encoding of the Categorical features 
one_hot_workclass=pd.get_dummies(data.workclass) 
one_hot_education=pd.get_dummies(data.education) 
one_hot_marital_Status=pd.get_dummies(data.marital_Status) 
one_hot_occupation=pd.get_dummies(data.occupation)
one_hot_relationship=pd.get_dummies(data.relationship) 
one_hot_race=pd.get_dummies(data.race) 
one_hot_sex=pd.get_dummies(data.sex) 
one_hot_native_country=pd.get_dummies(data.native_country) 

#removing categorical features 
data.drop(['workclass','education','marital_Status','occupation','relationship','race','sex','native_country'],axis=1,inplace=True) 

 

#Merging one hot encoded features with our dataset 'data' 
data=pd.concat([data,one_hot_workclass,one_hot_education,one_hot_marital_Status,one_hot_occupation,one_hot_relationship,one_hot_race,one_hot_sex,one_hot_native_country],axis=1) 

#removing dulpicate columns 
 _, i = np.unique(data.columns, return_index=True) 
data=data.iloc[:, i] 

#Here our target variable is 'Income' with values as 1 or 0.  
#Separating our data into features dataset x and our target dataset y 
x=data.drop('Income',axis=1) 
y=data.Income 

 

#Imputing missing values in our target variable 
y.fillna(y.mode()[0],inplace=True) 

#Now splitting our dataset into test and train 
from sklearn.model_selection import train_test_split 
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=.3)

#Aplicando xgboost

#The data is stored in a DMatrix object 
#label is used to define our outcome variable
dtrain=xgb.DMatrix(x_train,label=y_train)
dtest=xgb.DMatrix(x_test)
#setting parameters for xgboost
parameters={'max_depth':7, 'eta':1, 'silent':1,'objective':'binary:logistic','eval_metric':'auc','learning_rate':.05}
#training our model 
num_round=50
from datetime import datetime 
start = datetime.now() 
xg=xgb.train(parameters,dtrain,num_round) 
stop = datetime.now()
#Execution time of the model 
execution_time_xgb = stop-start 
execution_time_xgb
#datetime.timedelta( , , ) representation => (days , seconds , microseconds) 
#now predicting our model on test set 
ypred=xg.predict(dtest) 
ypred
#Converting probabilities into 1 or 0  
for i in range(0,9769): 
    if ypred[i]>=.5:       # setting threshold to .5 
       ypred[i]=1 
    else: 
       ypred[i]=0  
#calculating accuracy of our model 
from sklearn.metrics import accuracy_score 
accuracy_xgb = accuracy_score(y_test,ypred) 
accuracy_xgb

# Aplicando Light GBM

train_data=lgb.Dataset(x_train,label=y_train)
#setting parameters for lightgbm
param = {'num_leaves':150, 'objective':'binary','max_depth':7,'learning_rate':.05,'max_bin':200}
param['metric'] = ['auc', 'binary_logloss']
#Here we have set max_depth in xgb and LightGBM to 7 to have a fair comparison between the two.
#training our model using light gbm
num_round=50
start=datetime.now()
lgbm=lgb.train(param,train_data,num_round)
stop=datetime.now()
#Execution time of the model
execution_time_lgbm = stop-start
execution_time_lgbm
#predicting on test set
ypred2=lgbm.predict(x_test)
ypred2[0:5]  # showing first 5 predictions
#converting probabilities into 0 or 1
for i in range(0,9769):
    if ypred2[i]>=.5:       # setting threshold to .5
       ypred2[i]=1
    else:  
       ypred2[i]=0
#calculating accuracy
accuracy_lgbm = accuracy_score(ypred2,y_test)
accuracy_lgbm
y_test.value_counts()
from sklearn.metrics import roc_auc_score
#calculating roc_auc_score for xgboost
auc_xgb =  roc_auc_score(y_test,ypred)
auc_xgb
#calculating roc_auc_score for light gbm. 
auc_lgbm = roc_auc_score(y_test,ypred2)
auc_lgbm comparison_dict = {'accuracy score':(accuracy_lgbm,accuracy_xgb),'auc score':(auc_lgbm,auc_xgb),'execution time':(execution_time_lgbm,execution_time_xgb)}
#Creating a dataframe ‘comparison_df’ for comparing the performance of Lightgbm and xgb. 
comparison_df = DataFrame(comparison_dict) 
comparison_df.index= ['LightGBM','xgboost'] 
comparison_df

Comparación de rendimiento

 

Solo ha habido un ligero aumento en la precisión y la puntuación de AUC al aplicar Light GBM sobre XGBOOST, pero hay una diferencia significativa en el tiempo de ejecución del procedimiento de entrenamiento. Light GBM es casi 7 veces más rápido que XGBOOST y es un enfoque mucho mejor cuando se trata de grandes conjuntos de datos.

Esto resulta ser una gran ventaja cuando trabajas en grandes conjuntos de datos en competiciones de tiempo limitado.

 

6. Parámetros de ajuste de Light GBM (Hiperparámetros)

como hemos visto anteriormente overfittingLight GBM utiliza la división por hojas en lugar de la división por profundidad, lo que le permite converger mucho más rápido, pero también conduce a un Overfitting . Así que aquí les adjunto una guía rápida para ajustar los parámetros en Light GBM.

Para un mejor ajuste

  • num_leaves : Este parámetro se utiliza para establecer el número de hojas que se formarán en un árbol. Teóricamente, la relación entre num_hojas y max_ depth es num_leaves= 2^(max_ depth). Sin embargo, esta no es una buena estimación en el caso de Light GBM , ya que la división se realiza en forma de hoja y no en profundidad. Por lo tanto, el conjunto num_leaves debe ser menor que 2^(max_ depth), de lo contrario, puede provocar un ajuste excesivo. Light GBM no tiene una relación directa entre num_leaves y max_ depth y, por lo tanto, los dos no deben estar vinculados entre sí.
  • min_data_in_leaf : también es uno de los parámetros importantes para tratar el sobre el overfitting. Establecer su valor más pequeño puede causar un overfiting  y, por lo tanto, debe establecerse en consecuencia. Su valor debe ser de cientos a miles de grandes conjuntos de datos.
  • max_ depth : Especifica la profundidad máxima o el nivel hasta el que puede crecer el árbol.

 

Para mayor velocidad

  • bagging_fraction : se utiliza para realizar»bagging» y  para obtener resultados más rápidos
  • feature_fraction : establece la fracción de las funciones que se usarán en cada iteración
  • max_bin : un valor más pequeño de max_bin puede ahorrar mucho tiempo, ya que clasifica los valores de las características en contenedores discretos, lo que es computacionalmente mas económico.

 

Para una mejor precisión

  • Use un % de  datos de entrenamiento más grande
  • num_leaves : configurarlo en un valor alto produce árboles más profundos con mayor precisión, pero conduce al overfitting . Por lo tanto, no se prefiere su valor más alto.
  • max_bin : configurarlo en valores altos tiene un efecto similar al causado por el aumento del valor de num_leaves , lo cual podría provocar un  un proceso de entrenamiento mas lento.

 

7. Notas finales

En este pequeño articulo he tratado de dar algunas ideas muy generales sobre las ventajas que tiene el utilizar Light-GBM.  Aunque resulte paradójico una de las desventajas de utilizar este algoritmo podría ser el hecho de que no tantas personas lo utilizan actualmente sin embargo esto tendencia comienza a revertirse . Sin duda la Light-GBM es un algoritmo más preciso y ahora más tiempo que XG-BOOST y esta carencia podría deberse a que no existe mucha documentación sobre Light- GBM disponible

Posiblemente sea pronto para coronar a Light- GBM como el mejor algoritmo entre estos dos . Sin embargoLight GBM  desafía cada vez más a XG-BOOST.   Y al igual que con todos los algoritmos de Machine learning el principal Consejo es ¡asegúrese de ajustar correctamente los parámetros antes de entrenar el modelo!

 

————————-

El presente artículo , Light GBM vs XGBoost – ¿Cuál es mejor algoritmo ? es una adaptación y actualizado del artículo original escrito por :  Erlich_bachman Khandelwal — el 12 de junio de 2017.,La actualizaciòn y adaptaciòn en el 2022 fue realizada por el Dr. Juan Ignacio Barrios.  El Dr. Barrios es médico y cirujano especialista en informática médica. Posee una maestría en Business Intelligence y consultoría tecnológica.  Es experto en el tema de Big Data y ciencia de datos.  Aplica diariamente modelos de Machine learning e inteligencia artificial en el ámbito sanitario,  junto con una carrera docente como profesor visitante de la cátedra de informática médica en la Universidad de Barcelona labor que complementa con apoyo a diversas iniciativas tecnológicas relacionadas con el tema the Big Data en salud. Tambien es Faculty member de la Universidad de Rochester de los EUA en las facultades de Ginecología y Obstetricia y de Salud Pública desde el año 2000.

 

 

 

 

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

HTML Snippets Powered By : XYZScripts.com