Imagen por editor 
 

Hay 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 alumnos débiles para utilizar el resto de los atributos para 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 reduciendo sus errores. Hay dos técnicas populares de ensamblaje: embolsado y refuerzo. 

El embolsado, también conocido como Agregación Bootstrapped, 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 impulso, por otro lado, implica entrenar modelos individuales de forma secuencial, donde cada modelo intenta corregir los errores cometidos por los modelos anteriores.

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

LGBMClassifier significa clasificador de máquina de aumento de gradiente de luz. Utiliza algoritmos de árboles de decisión para clasificar, clasificar y otras tareas de aprendizaje automático. LGBMClassifier utiliza una técnica novedosa de muestreo de un lado basado en gradientes (GOSS) y agrupación de características exclusivas (EFB) para manejar datos a gran escala con precisión, haciéndolos más rápidos y reduciendo el uso de memoria.

¿Qué es el muestreo de un lado basado en gradiente (GOSS)?

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

¿Qué es el paquete de características exclusivas (EFB)?

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

El paquete LightGBM se puede instalar directamente usando pip, el administrador de paquetes de python. Escriba el comando compartido a continuación 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 usando el comando "conda install" como se indica a continuación.

conda install -c conda-forge lightgbm

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

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 de Kaggle o use el siguiente código para cargarlo directamente desde Seaborn, como se muestra a continuación:

titanic = sns.load_dataset('titanic')

Elimine columnas innecesarias como "cubierta", "embarque_ciudad" y "vivo" porque son redundantes o no contribuyen a la supervivencia de ninguna persona en el barco. A continuación, observamos que las características "edad", "tarifa" y "embarcado" tienen valores faltantes; tenga en cuenta que los diferentes atributos se imputan con medidas estadísticas apropiadas.

# Drop unnecessary columns
titanic = titanic.drop(['deck', 'embark_town', 'alive'], axis=1) # Replace missing values with the median or mode
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 iniciar el proceso de entrenamiento del modelo.

# Convert categorical variables to numerical variables
titanic['sex'] = pd.Categorical(titanic['sex']).codes
titanic['embarked'] = pd.Categorical(titanic['embarked']).codes # Split the dataset into input features and the target variable
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 de destino, así como conjuntos de entrenamiento y prueba mediante la función train_test_split de scikit-learn.

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Etiquetemos la codificación de datos categóricos ("quién") y ordinales ("clase") para garantizar que el modelo se suministre con datos numéricos, ya que LGBM no consume datos no numéricos.

class_dict = { "Third": 3, "First": 1, "Second": 2
}
who_dict = { "child": 0, "woman": 1, "man": 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 para el 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, evalúemos el rendimiento del clasificador entrenado en el conjunto de datos de prueba o no visto.

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 puede ajustar para un rendimiento óptimo. Aquí, discutiremos brevemente algunos de los hiperparámetros clave:

• num_hojas: Este es el parámetro principal para controlar la complejidad del modelo de árbol. Idealmente, el valor de num_hojas debería ser menor o igual a 2^(max_ depth).
• min_datos_en_hoja: Este es un parámetro importante para evitar el sobreajuste en un árbol de hojas. Su valor óptimo depende del número de muestras de entrenamiento y num_hojas.
• máxima profundidad: Puede usar esto para limitar la profundidad del árbol explícitamente. Es mejor ajustar este parámetro en caso de sobreajuste.

Ajustemos estos hiperparámetros y entrenemos un nuevo modelo:

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

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

 precision recall f1-score support 0 0.85 0.89 0.87 105 1 0.83 0.77 0.80 74 accuracy 0.84 179 macro avg 0.84 0.83 0.83 179
weighted avg 0.84 0.84 0.84 179

Tenga en cuenta que el ajuste real de los hiperparámetros es un proceso que implica prueba y error y también puede guiarse por la experiencia y una comprensión más profunda del algoritmo de refuerzo y la experiencia en la materia (conocimiento del dominio) del problema comercial en el que está 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 debe ser parte de su conjunto de herramientas de aprendizaje automático.
 
 
vidhi chugh es un estratega de inteligencia artificial y un 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 en innovación galardonada, autora y oradora internacional. Tiene la misión de democratizar el aprendizaje automático y romper la jerga para que todos sean parte de esta transformación.
 

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Automoción / vehículos eléctricos, Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• Desplazamientos de bloque. Modernización de la propiedad de compensaciones ambientales. Accede Aquí.
• Fuente: https://www.kdnuggets.com/2023/07/lgbmclassifier-gettingstarted-guide.html?utm_source=rss&utm_medium=rss&utm_campaign=lgbmclassifier-a-getting-started-guide