XGBoost para Classificação Binária em Python

A classificação binária é um tipo de tarefa de machine learning onde a saída é um resultado binário, ou seja, pertence a uma de duas classes.

Por exemplo, um e-mail pode ser classificado como ‘spam’ ou ’não spam’, ou um tumor pode ser ‘maligno’ ou ‘benigno’.

Quando você tem mais de duas classes, é chamado de classificação multiclasse.

Podemos usar vários algoritmos para resolver estes tipos de problemas.

Esses algoritmos incluem regressão logística, árvores de decisão, random forest, SVM e algoritmos de gradient boosting como o XGBoost.

XGBoost, abreviação de eXtreme Gradient Boosting, é um algoritmo popular de machine learning no campo de dados estruturados ou tabulares.

É um ensemble de machine learning baseado em árvores de decisão que usa um framework de gradient boosting.

Nas próximas seções, veremos como usar o XGBoost para classificação binária em Python.

Usaremos o Red Wine Quality Dataset.

Ele contém 11 features que descrevem as propriedades químicas de diferentes vinhos e uma pontuação de qualidade para cada um.

Vamos começar!

Instalando o XGBoost em Python

Antes de começarmos a usar o XGBoost, precisamos instalá-lo.

O XGBoost pode ser instalado usando o pip, que é um gerenciador de pacotes para Python.

Para instalá-lo, você pode usar o seguinte comando no seu terminal:

pip install xgboost

Se você estiver usando um notebook Jupyter, pode executar este comando em uma célula de código prefixando-o com um ponto de exclamação:

!pip install xgboost

Você também pode fazer isso usando conda e mamba:

conda install -c conda-forge xgboost

mamba install -c conda-forge xgboost

Depois de executar este comando, o XGBoost deve estar instalado e pronto para uso.

Você pode verificar se está instalado corretamente importando-o em seu script Python:

import xgboost as xgb

Se este comando for executado sem erros, parabéns! Você instalou o XGBoost com sucesso.

Agora, vamos passar para a próxima seção, onde discutiremos as funções objetivo (perda) para classificação binária.

Funções Objetivo (Perda) para Classificação Binária

No XGBoost, a função objetivo, também conhecida como função de perda, é usada para medir a diferença entre os resultados previstos e reais.

Ela guia o modelo no caminho que deve tomar durante o treinamento para alcançar a solução ótima.

Às vezes, é a mesma que a métrica de avaliação, mas não precisa ser.

Para classificação binária, o XGBoost fornece várias funções objetivo:

reg:logistic e binary:logistic

Você pode ficar confuso no início porque existem duas funções objetivo com nomes muito semelhantes: reg:logistic e binary:logistic.

De acordo com o criador da biblioteca, elas são iguais internamente.

A única diferença que você pode notar é que, se você usar a API nativa do XGBoost para treinar seu modelo, a métrica de avaliação padrão será RMSE para reg:logistic e Acurácia Binária para binary:logistic.

binary:logitraw

Para obter probabilidades a partir de pontuações brutas, normalmente passamos estas previsões por uma função sigmóide, que retorna um valor entre 0 e 1.

Esta função também realiza regressão logística, mas retorna a saída bruta não transformada, antes do passo de transformação da função sigmóide citada acima.

binary:hinge

A função de perda “hinge” é usada para classificação de “margem máxima”, usada notavelmente em SVMs.

Ela pode oferecer melhor generalização do que a perda logística em alguns casos, mas a desvantagem é que ela produz saídas binárias diretamente em vez de probabilidades.

Para produzir probabilidades, você precisaria calibrar o modelo usando um método como o escalonamento de Platt.

Na prática, recomendo experimentar diferentes funções para ver qual funciona melhor para o seu caso específico.

Na próxima seção, carregaremos nossos dados e começaremos a treinar nosso modelo XGBoost.

Carregando os Dados

Para carregar os dados, usaremos a biblioteca pandas, que é uma poderosa biblioteca de manipulação de dados em Python.

Se você não a tiver instalada, pode fazê-lo usando o pip:

pip install pandas

Agora, vamos carregar o conjunto de dados.

Ele está disponível como um arquivo CSV no Kaggle.

Usaremos a função read_csv() do pandas para carregar os dados em um DataFrame.

import pandas as pd

# Carregar os dados
dados = pd.read_csv('winequality-red.csv')

# Exibir as primeiras linhas dos dados
dados.head()

A função head() é usada para mostrar as primeiras n linhas do DataFrame.

Por padrão, retorna as primeiras 5 linhas.

Agora que carregamos nossos dados, podemos passar para o treinamento do nosso modelo XGBoost.

Treinando o XGBoost com a API do Scikit-Learn

O XGBoost se integra perfeitamente com a biblioteca Scikit-Learn, que fornece uma API consistente para muitos algoritmos diferentes de machine learning em Python.

Antes de começarmos o treinamento, precisamos preparar nossos dados.

Vamos separar nossa variável alvo (quality) do resto do conjunto de dados e dividir os dados em conjuntos de treinamento e teste.

A coluna quality original contém valores de 3 a 8, então precisamos convertê-la em uma variável binária.

Vamos considerar todo vinho com uma pontuação de qualidade de 7 ou mais como ‘bom’ (1) e o resto como ’não bom’ (0).

Poderíamos dizer que são ruins, mas isso pode ser um exagero já que vinhos com pontuações 6 são colocados no mesmo grupo 🙂.

from sklearn.model_selection import train_test_split

# Separar a variável alvo
X = dados.drop('quality', axis=1)
y = dados['quality'].map(lambda x: 1 if x >= 7 else 0)

# Dividir os dados em conjuntos de treinamento e teste
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_state=42)

Agora, vamos treinar nosso modelo XGBoost.

Usaremos a classe XGBClassifier da biblioteca XGBoost que, como o nome sugere, é usada para criar um classificador XGBoost.

from xgboost import XGBClassifier

# Criar uma instância do XGBClassifier
xgb_classificador = XGBClassifier(objective='binary:logistic')

xgb_classificador.fit(X_treino, y_treino)

Se você já usou o Scikit-Learn antes, este código será familiar.

A função fit() treina o modelo nos dados de treinamento.

Passamos as features (X_treino) e o alvo (y_treino) como parâmetros para esta função.

Existem muitos hiperparâmetros que você pode ajustar para melhorar o desempenho do seu modelo, como o número de árvores, a profundidade máxima das árvores, a taxa de aprendizado e muitos outros.

Neste exemplo, usamos os hiperparâmetros padrão.

Agora que nosso modelo está treinado, podemos usá-lo para fazer previsões.

Fazendo Previsões

Existem duas maneiras de fazer previsões usando o XGBoost que você deve conhecer:

Previsões de Classe

Se você quiser prever a classe de uma instância, diretamente, com um limiar de 0,5, pode usar a função predict().

# Fazer previsões de classe
y_pred = xgb_classificador.predict(X_teste)

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, ...]

Neste caso, cada instância com probabilidade maior que 0,5 será classificada como ‘boa’ (1) e o resto como ’não boa’ (0).

Prevendo Probabilidades

Na maioria das vezes, queremos saber as probabilidades de uma instância pertencer a cada classe, para que possamos usar um limiar diferente de 0,5 ou usar as probabilidades diretamente em etapas posteriores.

Digamos que estamos prevendo se uma ação subirá ou descerá nos próximos dias.

Um gestor de portfólio pode inserir essas previsões em uma fórmula de valor esperado para decidir se deve comprar ou vender a ação.

A função predict_proba() retorna as probabilidades para cada classe.

# Prever probabilidades
y_pred_proba = xgb_classificador.predict_proba(X_teste)

array([[9.98416662e-01, 1.58336537e-03],
       [9.99976218e-01, 2.38024204e-05],
       [9.98861015e-01, 1.13899994e-03],
       [9.99696195e-01, 3.03776585e-04],
       ...]

A coluna da esquerda é a probabilidade da instância pertencer à classe negativa (0) e a coluna da direita é a probabilidade de pertencer à classe positiva (1).

Na próxima seção, avaliaremos o desempenho do nosso modelo.

Isso nos dará uma ideia de quão bem nosso modelo está se saindo em vinhos que nunca viu antes.

Avaliando o Desempenho do Modelo XGBoost

Avaliar o desempenho de um modelo é uma etapa crucial em machine learning.

Isso nos ajuda a entender quão bem nosso modelo está se saindo e onde pode ser melhorado.

Vamos ver algumas maneiras de fazer isso.

Função score

Esta é a maneira mais simples de obter uma avaliação do seu modelo em um conjunto de dados.

No XGBoost, ela retorna a acurácia média nos dados de teste.

# Calcular acurácia
acuracia = xgb_classificador.score(X_teste, y_teste)
print("Acurácia: %.2f%%" % (acuracia * 100.0))

Usando Métricas de Avaliação do Scikit-learn

O Scikit-learn fornece várias funções para calcular métricas como precisão, recall, pontuação F1, ROC AUC e Log Loss.

Para usar funções como Log Loss e ROC AUC, precisamos obter as probabilidades para cada classe.

from sklearn.metrics import log_loss, roc_auc_score

# Calcular log loss
log_loss(y_teste, y_pred_proba)

# Calcular ROC AUC
roc_auc_score(y_teste, y_pred_proba[:,1])

Observe que, na segunda linha, usamos y_pred_proba[:,1] em vez de y_pred_proba, pois só precisamos das probabilidades para a classe positiva.

A função classification_report() imprime a precisão, recall, pontuação F1 e suporte para cada classe.

from sklearn.metrics import classification_report

# Imprimir relatório de classificação
print(classification_report(y_teste, y_pred))

Lembre-se, não existe uma métrica única que seja a melhor para todos os problemas.

É importante olhar para múltiplas métricas e entender o que elas significam no contexto do seu problema específico.

Hiperparâmetros Importantes do XGBoost

O XGBoost tem vários hiperparâmetros importantes (às vezes chamados apenas de parâmetros na documentação) que podem impactar significativamente o desempenho do seu modelo.

Ajustar esses parâmetros é crucial para obter o máximo do XGBoost.

Aqui estão alguns dos principais hiperparâmetros que você deve considerar:

learning_rate

O parâmetro learning_rate controla o ritmo em que o modelo aprende.

Ela decide quanto cada árvore de decisão contribui para a previsão final.

Uma taxa de aprendizado menor pode prevenir o overfitting, mas também pode exigir mais iterações para convergir.

Uma taxa de aprendizado maior pode acelerar a convergência, mas também pode fazer com que o modelo nunca atinja o mínimo da função de perda.

max_depth

O parâmetro max_depth representa a profundidade máxima de cada árvore de decisão no ensemble.

Um valor mais alto permite que o modelo aprenda padrões mais complexos nos dados, mas também pode levar ao overfitting.

Por outro lado, um valor mais baixo pode prevenir o overfitting, mas pode resultar em underfitting.

subsample

O parâmetro subsample representa a fração de amostras usadas para cada árvore de decisão.

Ao usar um subconjunto dos dados de treinamento para cada árvore, o XGBoost introduz aleatoriedade, o que pode ajudar a reduzir o overfitting e melhorar a generalização.

Tenha em mente que aqui fazemos amostragem sem reposição, o que é diferente do bootstrapping comum na Random Forest.

colsample_bytree

O parâmetro colsample_bytree representa a fração de features usadas para cada árvore de decisão.

Semelhante ao subsample, ele introduz aleatoriedade usando um subconjunto de features para cada árvore, o que pode ajudar a prevenir o overfitting e melhorar a generalização.

Também existem colsample_bylevel e colsample_bynode para amostragem de colunas em diferentes pontos do processo de construção da árvore.

n_estimators

O parâmetro n_estimators é um parâmetro obrigatório que determina o número de iterações de boosting e controla a complexidade geral do modelo.

Um número maior de estimadores, com uma pequena taxa de aprendizado, geralmente leva a um melhor desempenho, mas também pode aumentar o risco de overfitting e o custo computacional.

E é isso!

Agora você aprendeu como usar o XGBoost para classificação binária em Python.