Light GBM vs XGBoost . ¿Cuál es mejor el algoritmo ?
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 ?
- ¿Qué es Light GBM?
- Ventajas de Light GBM
- Instalación de Light GBM
- Parámetros importantes de Light GBM
- Light GBM frente a XGBOOST
- Parámetros de ajuste de Light GBM
- 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
- 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.
- Menor uso de memoria: reemplaza los valores continuos por contenedores discretos, lo que da como resultado un menor uso de memoria.
- 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.
- 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.
- 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
-
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/.
-
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
-
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.