LGBMClassifier Una Guía de Inicio Rápido

LGBMClassifier Guía de Inicio Rápido

 

Existen una gran cantidad de algoritmos de aprendizaje automático que son aptos para modelar fenómenos específicos. Mientras que algunos modelos utilizan un conjunto de atributos para superar a otros, otros incluyen aprendices débiles para utilizar el resto de atributos y proporcionar información adicional al modelo, conocidos como modelos de conjunto.

La premisa de los modelos de conjunto es mejorar el rendimiento del modelo combinando las predicciones de diferentes modelos y reduciendo sus errores. Hay dos técnicas populares de conjunto: bagging y boosting.

El bagging, también conocido como agregación bootstrap, entrena múltiples modelos individuales en diferentes subconjuntos aleatorios de los datos de entrenamiento y luego promedia sus predicciones para producir la predicción final. El boosting, por otro lado, implica entrenar modelos individuales secuencialmente, donde cada modelo intenta corregir los errores cometidos por los modelos anteriores.

• Inmersión profunda en las Unidades Recurrentes con Puertas (GRU) Entendiendo las Matemáticas detrás de las RNN
• Explorando NLP – Comenzando con NLP (Paso #1)
• Explorando el Procesamiento del Lenguaje Natural – Inicio de NLP (Paso #2)

Ahora que tenemos contexto sobre los modelos de conjunto, hagamos doble clic en el modelo de conjunto de boosting, específicamente el algoritmo Light GBM (LGBM) desarrollado por Microsoft. 

 

¿Qué es LGBMClassifier?

 

LGBMClassifier significa Light Gradient Boosting Machine Classifier. Utiliza algoritmos de árboles de decisión para clasificación, ranking y otras tareas de aprendizaje automático. LGBMClassifier utiliza una técnica novedosa llamada Gradient-based One-Side Sampling (GOSS) y Exclusive Feature Bundling (EFB) para manejar datos a gran escala con precisión, lo que lo hace más rápido y reduce el uso de memoria.

 

¿Qué es Gradient-based One-Side Sampling (GOSS)?

 

Los algoritmos tradicionales de boosting utilizan todos los datos para el entrenamiento, lo cual puede ser lento cuando se trata de conjuntos de datos grandes. GOSS de LightGBM, por otro lado, conserva todas las instancias con grandes gradientes y realiza un muestreo aleatorio en las instancias con gradientes pequeños. La intuición detrás de esto es que las instancias con grandes gradientes son más difíciles de ajustar y, por lo tanto, llevan más información. GOSS introduce un multiplicador constante para las instancias de datos con gradientes pequeños para compensar la pérdida de información durante el muestreo.

 

¿Qué es Exclusive Feature Bundling (EFB)?

 

En un conjunto de datos disperso, la mayoría de las características son cero. EFB es un algoritmo casi sin pérdidas que combina características mutuamente exclusivas (características que no son no nulas simultáneamente) para reducir el número de dimensiones, acelerando así el proceso de entrenamiento. Dado que estas características son “exclusivas”, el espacio de características original se conserva sin pérdida significativa de información.

 

Instalación

 

El paquete LightGBM se puede instalar directamente utilizando pip, el administrador de paquetes de python. Escriba el siguiente comando ya sea en la terminal o en el símbolo del sistema para descargar e instalar la biblioteca LightGBM en su máquina:

pip install lightgbm

 

Los usuarios de Anaconda pueden instalarlo utilizando el comando “conda install” como se muestra a continuación.

conda install -c conda-forge lightgbm

 

Según su sistema operativo, puede elegir el método de instalación utilizando esta guía.

 

¡Práctica!

 

Ahora, importemos LightGBM y otras bibliotecas necesarias:

import numpy as np
import pandas as pd
import seaborn as sns
import lightgbm as lgb
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

 

Preparando el conjunto de datos

 

Estamos utilizando el popular conjunto de datos Titanic, que contiene información sobre los pasajeros del Titanic, con la variable objetivo que indica si sobrevivieron o no. Puede descargar el conjunto de datos desde Kaggle o utilizar el siguiente código para cargarlo directamente desde Seaborn, como se muestra a continuación:

titanic = sns.load_dataset('titanic')

 

Elimine las columnas innecesarias como “deck”, “embark_town” y “alive” porque son redundantes o no contribuyen a la supervivencia de ninguna persona en el barco. A continuación, observamos que las características “age”, “fare” y “embarked” tienen valores faltantes, tenga en cuenta que los diferentes atributos se imputan con medidas estadísticas apropiadas.

# Eliminar columnas innecesarias
titanic = titanic.drop(['deck', 'embark_town', 'alive'], axis=1)

# Reemplazar valores faltantes con la mediana o moda
titanic['age'] = titanic['age'].fillna(titanic['age'].median())
titanic['fare'] = titanic['fare'].fillna(titanic['fare'].mode()[0])
titanic['embarked'] = titanic['embarked'].fillna(titanic['embarked'].mode()[0])

 

Por último, convertimos las variables categóricas en variables numéricas utilizando los códigos categóricos de pandas. Ahora, los datos están preparados para comenzar el proceso de entrenamiento del modelo.

# Convertir variables categóricas en variables numéricas
titanic['sex'] = pd.Categorical(titanic['sex']).codes
titanic['embarked'] = pd.Categorical(titanic['embarked']).codes

# Dividir el conjunto de datos en características de entrada y variable objetivo
X = titanic.drop('survived', axis=1)
y = titanic['survived']

 

Entrenamiento del modelo LGBMClassifier

 

Para comenzar a entrenar el modelo LGBMClassifier, necesitamos dividir el conjunto de datos en características de entrada y variables objetivo, así como conjuntos de entrenamiento y pruebas utilizando la función train_test_split de scikit-learn.

# Dividir el conjunto de datos en conjuntos de entrenamiento y pruebas
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

 

Etiquetamos los datos categóricos (“who”) y los datos ordinales (“class”) para asegurarnos de que el modelo reciba datos numéricos, ya que LGBM no puede procesar datos no numéricos.

class_dict = {
"Tercera": 3,
"Primera": 1,
"Segunda": 2
}
who_dict = {
"niño": 0,
"mujer": 1,
"hombre": 2
}
X_train['class'] = X_train['class'].apply(lambda x: class_dict[x])
X_train['who'] = X_train['who'].apply(lambda x: who_dict[x])
X_test['class'] = X_test['class'].apply(lambda x: class_dict[x])
X_test['who'] = X_test['who'].apply(lambda x: who_dict[x])

 

A continuación, especificamos los hiperparámetros del modelo como argumentos del constructor, o podemos pasarlos como un diccionario al método set_params.

El último paso para iniciar el entrenamiento del modelo es cargar el conjunto de datos creando una instancia de la clase LGBMClassifier y ajustándola a los datos de entrenamiento.

params = {
'objective': 'binary',
'boosting_type': 'gbdt',
'num_leaves': 31,
'learning_rate': 0.05,
'feature_fraction': 0.9
}
clf = lgb.LGBMClassifier(**params)
clf.fit(X_train, y_train)

 

A continuación, evaluamos el rendimiento del clasificador entrenado en el conjunto de datos de prueba.

predictions = clf.predict(X_test)
print(classification_report(y_test, predictions))

 

             precision    recall  f1-score   support

           0       0.84      0.89      0.86       105
           1       0.82      0.76      0.79        74

    accuracy                           0.83       179
   macro avg       0.83      0.82      0.82       179
weighted avg       0.83      0.83      0.83       179

 

Ajuste de hiperparámetros

 

El LGBMClassifier permite mucha flexibilidad a través de hiperparámetros que se pueden ajustar para obtener un rendimiento óptimo. Aquí discutiremos brevemente algunos de los hiperparámetros clave:

• num_leaves: Este es el parámetro principal para controlar la complejidad del modelo de árbol. Idealmente, el valor de num_leaves debe ser menor o igual a 2^(max_depth).
• min_data_in_leaf: Este es un parámetro importante para evitar el sobreajuste en un árbol de hoja a hoja. Su valor óptimo depende del número de muestras de entrenamiento y num_leaves.
• max_depth: Se puede utilizar para limitar explícitamente la profundidad del árbol. Es mejor ajustar este parámetro en caso de sobreajuste.

</

Ajustemos estos hiperparámetros y entrenemos un nuevo modelo:

modelo = lgb.LGBMClassifier(num_leaves=31, min_data_in_leaf=20, max_depth=5)
modelo.fit(X_train, y_train)

 

predicciones = modelo.predict(X_test)
print(classification_report(y_test, predicciones))

 

             precisión    recall  puntuación-f1   soporte

           0       0.85      0.89      0.87       105
           1       0.83      0.77      0.80        74

    precisión global                           0.84       179
   promedio ponderado       0.84      0.84      0.84       179

 

Ten en cuenta que el ajuste real de hiperparámetros es un proceso que implica prueba y error y también puede estar guiado por la experiencia y una comprensión más profunda del algoritmo de refuerzo y el conocimiento del dominio del problema comercial en el que estás trabajando.

En esta publicación, aprendiste sobre el algoritmo LightGBM y su implementación en Python. Es una técnica flexible que es útil para varios tipos de problemas de clasificación y debería ser parte de tu conjunto de herramientas de aprendizaje automático.     Vidhi Chugh es una estratega de IA y líder de transformación digital que trabaja en la intersección de productos, ciencias e ingeniería para construir sistemas escalables de aprendizaje automático. Es una líder galardonada en innovación, autora y conferencista internacional. Está en una misión para democratizar el aprendizaje automático y romper la jerga para que todos puedan ser parte de esta transformación.  

We will continue to update Zepes; if you have any questions or suggestions, please contact us!