Regressão Multi-Output com XGBoost em Python

A regressão multi-output é uma tarefa de machine learning onde precisamos prever múltiplos valores para cada amostra de entrada.

Imagine que você é um analista financeiro em uma empresa de investimentos.

Seu trabalho é prever o desempenho futuro de várias ações para orientar decisões de investimento.

Para cada ação, você quer prever vários alvos, como o retorno esperado, a volatilidade (risco) e a correlação com outras ações ou índices de mercado.

Esses alvos estão inter-relacionados e dependem de um conjunto comum de variáveis de entrada, como a saúde financeira da empresa, condições de mercado, indicadores econômicos e assim por diante.

Neste caso, você pode usar um modelo de regressão multi-output.

O modelo receberá todos os dados financeiros relevantes e produzirá o retorno esperado, a volatilidade e a correlação para cada ação.

Neste tutorial, vamos explorar como usar o XGBoost, uma poderosa biblioteca de machine learning, para abordar este problema de modelagem.

Vou guiá-lo através do processo passo a passo, desde a instalação do XGBoost e carregamento dos seus dados, até o treinamento do modelo e avaliação do seu desempenho.

Ao final deste tutorial, você saberá como usar o XGBoost para regressão multi-output em Python e estará pronto para aplicar esse conhecimento aos seus próprios projetos.

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 Jupyter Notebook ou Colab, você 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

Após 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.

Carregando os Dados

Vamos importar os pacotes necessários e carregar nosso conjunto de dados.

Especificamente, estamos usando pandas para carregar os dados em um DataFrame e NumPy para trabalhar com arrays.

import pandas as pd
import numpy as np

caminho_dados = "caminho_para_seus_dados"
dados = pd.read_csv(caminho_dados)

pd.read_csv(caminho_dados) lê o arquivo CSV no diretório indicado local e carrega como um DataFrame pandas.

Para exemplificar, usarei um conjunto de dados que representa dados de sensores coletados de um Motor Síncrono de Ímã Permanente (PMSM).

É uma coleção de medições feitas a uma taxa de 2 Hz durante várias sessões de teste.

Cada sessão de teste é identificada por um “profile_id” único e pode durar entre uma e seis horas.

O conjunto de dados inclui variáveis como tensões em coordenadas d/q (“u_d” e “u_q”), correntes em coordenadas d/q (“i_d” e “i_q”), velocidade do motor, torque e outras.

Não faço ideia do que a maioria dessas variáveis significa, mas isso não importa para o propósito deste tutorial.

Com todas essas informações, queremos usar machine learning para construir um modelo que possa prever o desempenho do PMSM com base nos dados dos sensores fornecidos.

Especificamente, queremos prever os valores ‘pm’, ‘stator_yoke’, ‘stator_tooth’, ‘stator_winding’, pois estes representam aspectos importantes do desempenho do motor.

Não se preocupe muito com os detalhes do conjunto de dados, é apenas um conjunto de dados limpo com múltiplos alvos que serve como um bom exemplo para regressão multi-output.

Tudo o que você aprender aqui pode ser aplicado aos seus próprios conjuntos de dados.

Treinando o XGBoost com Suporte Nativo para Regressão multi-output

Agora que temos nossos dados carregados, vamos passar para a parte emocionante - treinar nosso modelo XGBoost!

Desde a versão 1.6.0, o XGBoost tem suporte nativo para regressão e classificação multi-output.

Esta é a forma recomendada de treinar modelos multi-output com ele, então vou mostrar esta abordagem primeiro.

Antes de podermos fazer isso, precisamos dividir nossos dados em entrada (features) e saída (alvos).

# Definir as features e os alvos
features = dados.drop(['pm', 'stator_yoke', 'stator_tooth', 'stator_winding'], axis=1)
alvos = dados[['pm', 'stator_yoke', 'stator_tooth', 'stator_winding']]

No código acima, estamos usando a função drop para remover as colunas que queremos usar como alvos do DataFrame e não queremos incluir como features.

Em seguida, estamos criando um novo DataFrame apenas com essas colunas para usar como nossos alvos.

A seguir, vamos dividir nossos dados em conjuntos de treinamento e teste.

Isso nos permite avaliar o quão bem nosso modelo se comporta com dados não vistos (que é o que importa).

from sklearn.model_selection import train_test_split

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

A função train_test_split embaralha nossos dados e então os divide.

Estamos usando 80% dos dados para treinamento e 20% para teste.

Agora, estamos prontos para treinar nosso modelo.

Para isso, usaremos a classe XGBRegressor do XGBoost.

from xgboost import XGBRegressor

# Definir e treinar o modelo
modelo = XGBRegressor(tree_method='hist')

modelo.fit(X_treino, y_treino)

Aqui, estamos criando uma instância de XGBRegressor e treinando-a usando nossos dados de treinamento.

Ele detectará automaticamente que estamos fazendo regressão multi-output e treinará um modelo para cada saída.

Usei tree_method='hist' para acelerar o processo de treinamento, já que ele usará um algoritmo baseado em histograma para construir as árvores em vez do algoritmo exato, que é muito mais lento.

Após executar este código, nosso modelo está treinado e pronto para fazer previsões!

Treinando o XGBoost com o MultiOutputRegressor do Scikit-learn

Embora eu não recomende, agora que o XGBoost tem suporte nativo para regressão multi-output, você pode usar o MultiOutputRegressor do Scikit-learn para treinar um modelo multi-output com XGBoost.

Isso pode ser útil se você estiver trabalhando com uma versão mais antiga do XGBoost ou se quiser usar um recurso específico do Scikit-learn.

Primeiro, importe o MultiOutputRegressor do Scikit-learn.

from sklearn.multioutput import MultiOutputRegressor

Então, crie uma instância de XGBRegressor como antes.

xgb_regressor = XGBRegressor(tree_method='hist')

Em seguida, passe seu XGBRegressor ao objeto MultiOutputRegressor.

regressor_multisaida = MultiOutputRegressor(xgb_regressor)

Agora, você pode treinar o modelo usando o método fit do MultiOutputRegressor.

regressor_multisaida.fit(X_treino, y_treino)

Por baixo dos panos, MultiOutputRegressor treina um regressor XGBoost por coluna de saída.

Assim como antes, após executar este código, seu modelo está treinado e pronto para fazer previsões!

Fazendo Previsões

Não há diferença quando se trata de fazer previsões com a primeira ou segunda abordagem.

Em ambos, você pode usar a função predict() para fazer previsões em novos dados.

y_pred = modelo.predict(X_teste)

Da esquerda para a direita, as colunas representam os valores previstos para ‘pm’, ‘stator_yoke’, ‘stator_tooth’, ‘stator_winding’.

Avaliando o Desempenho do Modelo com Métricas do Scikit-learn

Depois de fazer previsões com seu modelo, o próximo passo é avaliar o quão bem essas previsões correspondem aos valores reais.

Para isso, usaremos as métricas do Scikit-learn.

Existem muitas métricas diferentes que poderíamos usar, já que as mesmas da regressão de saída única se aplicam aqui, mas neste tutorial, nos concentraremos no Erro Médio Absoluto (MAE) e na Raiz do Erro Quadrático Médio (RMSE).

Primeiro, vamos importar as funções necessárias:

from sklearn.metrics import mean_absolute_error, mean_squared_error

Erro Médio Absoluto (MAE)

O MAE é a média das diferenças absolutas entre os valores previstos e reais.

Podemos calcular o MAE em Python usando a função mean_absolute_error:

mae = mean_absolute_error(y_teste, y_pred)
print(f"Erro Médio Absoluto: {mae}")

Raiz do Erro Quadrático Médio (RMSE)

O RMSE é a raiz quadrada da média das diferenças quadráticas entre os valores previstos e reais.

Podemos calcular o RMSE em Python usando a função mean_squared_error com squared=False:

rmse = mean_squared_error(y_teste, y_pred, squared=False)
print(f"Raiz do Erro Quadrático Médio: {rmse}")

E é isso!

Você agora sabe treinar, fazer previsões e avaliar um modelo de regressão multi-output com XGBoost em Python.