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)
u_q | coolant | stator_winding | u_d | stator_tooth | motor_speed | i_d | i_q | pm | stator_yoke | ambient | torque | profile_id |
---|---|---|---|---|---|---|---|---|---|---|---|---|
-0.450682 | 18.8052 | 19.0867 | -0.350055 | 18.2932 | 0.00286557 | 0.00441914 | 0.000328102 | 24.5542 | 18.3165 | 19.8507 | 0.187101 | 17 |
-0.325737 | 18.8186 | 19.0924 | -0.305803 | 18.2948 | 0.000256782 | 0.000605872 | -0.000785353 | 24.5381 | 18.315 | 19.8507 | 0.245417 | 17 |
-0.440864 | 18.8288 | 19.0894 | -0.372503 | 18.2941 | 0.00235497 | 0.00128959 | 0.000386468 | 24.5447 | 18.3263 | 19.8507 | 0.176615 | 17 |
-0.327026 | 18.8356 | 19.083 | -0.316199 | 18.2925 | 0.00610467 | 2.55843e-05 | 0.00204566 | 24.554 | 18.3308 | 19.8506 | 0.238303 | 17 |
-0.47115 | 18.857 | 19.0825 | -0.332272 | 18.2914 | 0.00313282 | -0.0643168 | 0.0371838 | 24.5654 | 18.3267 | 19.8506 | 0.208197 | 17 |
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.
Seja o primeiro a saber das novidades em Machine Learning. Me siga no LinkedIn.