LGBMClassifier: A Getting Started Guide - KDnuggets

Republicado por Platão

seguidores: 0

LGBMClassifier: um guia de introdução
Imagem do editor

Há um grande número de algoritmos de aprendizado de máquina que são capazes de modelar fenômenos específicos. Enquanto alguns modelos utilizam um conjunto de atributos para superar outros, outros incluem alunos fracos para utilizar o restante dos atributos para fornecer informações adicionais ao modelo, conhecidos como modelos de conjunto.

A premissa dos modelos ensemble é melhorar o desempenho do modelo combinando as previsões de diferentes modelos reduzindo seus erros. Existem duas técnicas de ensemble populares: bagging e boosting.

Bagging, também conhecido como Bootstrapped Aggregation, treina vários modelos individuais em diferentes subconjuntos aleatórios dos dados de treinamento e calcula a média de suas previsões para produzir a previsão final. Boosting, por outro lado, envolve treinar modelos individuais sequencialmente, onde cada modelo tenta corrigir os erros cometidos pelos modelos anteriores.

Agora que temos contexto sobre os modelos de conjunto, vamos clicar duas vezes no modelo de conjunto de reforço, especificamente o algoritmo Light GBM (LGBM) desenvolvido pela Microsoft.

LGBMClassifier significa Light Gradient Boosting Machine Classifier. Ele usa algoritmos de árvore de decisão para classificação, classificação e outras tarefas de aprendizado de máquina. O LGBMClassifier usa uma nova técnica de amostragem unilateral baseada em gradiente (GOSS) e agrupamento de recursos exclusivos (EFB) para lidar com dados de grande escala com precisão, tornando-os mais rápidos e reduzindo o uso de memória.

O que é Amostragem unilateral baseada em gradiente (GOSS)?

Os algoritmos de aumento de gradiente tradicionais usam todos os dados para treinamento, o que pode ser demorado ao lidar com grandes conjuntos de dados. O GOSS do LightGBM, por outro lado, mantém todas as instâncias com grandes gradientes e executa amostragem aleatória nas instâncias com pequenos gradientes. A intuição por trás disso é que instâncias com grandes gradientes são mais difíceis de ajustar e, portanto, carregam mais informações. GOSS introduz um multiplicador constante para as instâncias de dados com pequenos gradientes para compensar a perda de informação durante a amostragem.

O que é o pacote de recursos exclusivos (EFB)?

Em um conjunto de dados esparso, a maioria dos recursos são zeros. EFB é um algoritmo quase sem perdas que agrupa/combina recursos mutuamente exclusivos (recursos que não são diferentes de zero simultaneamente) para reduzir o número de dimensões, acelerando assim o processo de treinamento. Como esses recursos são “exclusivos”, o espaço de recursos original é mantido sem perda significativa de informações.

O pacote LightGBM pode ser instalado diretamente usando o gerenciador de pacotes do pip – python. Digite o comando compartilhado abaixo no terminal ou no prompt de comando para baixar e instalar a biblioteca LightGBM em sua máquina:

pip install lightgbm

Os usuários do Anaconda podem instalá-lo usando o comando “conda install” conforme listado abaixo.

conda install -c conda-forge lightgbm

Com base no seu sistema operacional, você pode escolher o método de instalação usando este guia.

Agora, vamos importar LightGBM e outras bibliotecas necessárias:

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 o conjunto de dados

Estamos usando o popular conjunto de dados do Titanic, que contém informações sobre os passageiros do Titanic, com a variável de destino significando se eles sobreviveram ou não. Você pode baixar o conjunto de dados de Kaggle ou use o seguinte código para carregá-lo diretamente da Seaborn, conforme mostrado abaixo:

titanic = sns.load_dataset('titanic')

Elimine colunas desnecessárias como “deck”, “embark_town” e “alive” porque são redundantes ou não contribuem para a sobrevivência de qualquer pessoa no navio. Em seguida, observamos que os atributos “idade”, “tarifa” e “embarcou” possuem valores ausentes – observe que diferentes atributos são imputados com medidas estatísticas apropriadas.

# 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 fim, convertemos as variáveis categóricas em variáveis numéricas usando os códigos categóricos dos pandas. Agora, os dados estão preparados para iniciar o processo de treinamento do 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']

Treinando o modelo LGBMClassifier

Para começar a treinar o modelo LGBMClassifier, precisamos dividir o conjunto de dados em recursos de entrada e variáveis de destino, bem como conjuntos de treinamento e teste usando a função train_test_split do 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)

Vamos rotular os dados categóricos (“quem”) e ordinais (“classe”) para garantir que o modelo seja fornecido com dados numéricos, já que o LGBM não consome dados não 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])

Em seguida, especificamos os hiperparâmetros do modelo como argumentos para o construtor ou podemos passá-los como um dicionário para o método set_params.

A última etapa para iniciar o treinamento do modelo é carregar o conjunto de dados criando uma instância da classe LGBMClassifier e ajustando-a aos dados de treinamento.

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)

Em seguida, vamos avaliar o desempenho do classificador treinado no conjunto de dados não visto ou de teste.

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

O LGBMClassifier permite muita flexibilidade por meio de hiperparâmetros que você pode ajustar para um desempenho ideal. Aqui, discutiremos brevemente alguns dos principais hiperparâmetros:

num_folhas: Este é o principal parâmetro para controlar a complexidade do modelo de árvore. Idealmente, o valor de num_leaves deve ser menor ou igual a 2^(max_depth).
min_data_in_leaf: Este é um parâmetro importante para evitar o overfitting em uma árvore folha a folha. Seu valor ideal depende do número de amostras de treinamento e num_leaves.
profundidade máxima: você pode usar isso para limitar explicitamente a profundidade da árvore. É melhor ajustar este parâmetro em caso de overfitting.

Vamos ajustar esses hiperparâmetros e treinar um novo 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

Observe que o ajuste real de hiperparâmetros é um processo que envolve tentativa e erro e também pode ser guiado pela experiência e uma compreensão mais profunda do algoritmo de reforço e especialização no assunto (conhecimento do domínio) do problema de negócios em que você está trabalhando.

Nesta postagem, você aprendeu sobre o algoritmo LightGBM e sua implementação em Python. É uma técnica flexível que é útil para vários tipos de problemas de classificação e deve fazer parte do seu kit de ferramentas de aprendizado de máquina.

Vidhi Chugh é um estrategista de IA e um líder de transformação digital que trabalha na interseção de produtos, ciências e engenharia para construir sistemas escaláveis de aprendizado de máquina. Ela é uma líder em inovação premiada, autora e palestrante internacional. Ela tem a missão de democratizar o aprendizado de máquina e quebrar o jargão para que todos façam parte dessa transformação.