Regressão Avançada em Python: Modelando Relações Complexas
1. Conceitos Fundamentais
Antes de partir para a prática, é importante entender alguns conceitos-chave:
Regressão Linear Múltipla: Extensão da regressão linear simples, onde múltiplas variáveis independentes explicam a variável dependente.
Polinomial: Permite modelar relações não-lineares ao incluir potências das variáveis independentes.
Regularização: Técnicas como Ridge e Lasso previnem overfitting ao penalizar coeficientes excessivamente grandes.
Interações: Modelos que capturam o efeito combinado de duas ou mais variáveis sobre o resultado.
Modelos Baseados em Árvores: Algoritmos como Decision Trees e Gradient Boosting podem capturar relações complexas sem necessidade de transformar os dados.
2. Preparando o ambiente em Python
Para este tutorial, instale as bibliotecas essenciais:
pip install pandas numpy matplotlib seaborn scikit-learn statsmodels xgboost
Importando as bibliotecas:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.metrics import mean_squared_error, r2_score
import statsmodels.api as sm
3. Exemplo prático: Previsão de preços de imóveis
Suponha que temos um dataset com informações sobre imóveis, incluindo área, número de quartos, idade do imóvel e distância até o centro. O objetivo é prever o preço de venda.
# Criando dataset fictício
data = {
'Area': [50, 80, 120, 60, 100, 90, 200, 150, 130, 170],
'Quartos': [1, 2, 3, 1, 2, 2, 4, 3, 3, 4],
'Idade': [5, 10, 15, 7, 12, 8, 20, 18, 14, 22],
'Distancia_centro': [5, 10, 8, 6, 7, 9, 15, 12, 10, 14],
'Preco': [150, 200, 300, 180, 250, 220, 400, 350, 320, 380]
}
df = pd.DataFrame(data)
3.1 Análise exploratória
Visualizando relações entre variáveis:
sns.pairplot(df, x_vars=['Area','Quartos','Idade','Distancia_centro'], y_vars='Preco', height=4, kind='scatter')
plt.show()
Essa etapa ajuda a identificar relações lineares e não-lineares entre variáveis e o preço.
4. Regressão Linear Múltipla
X = df[['Area','Quartos','Idade','Distancia_centro']]
y = df['Preco']
# Dividindo em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Modelo Linear
lin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)
# Previsões
y_pred = lin_reg.predict(X_test)
# Avaliação
print("R2:", r2_score(y_test, y_pred))
print("RMSE:", np.sqrt(mean_squared_error(y_test, y_pred)))
A regressão linear múltipla é rápida e interpretável, mas pode não capturar relações não-lineares.
5. Regressão Polinomial
Para capturar relações não-lineares, podemos incluir features polinomiais:
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)
X_train_poly, X_test_poly, y_train, y_test = train_test_split(X_poly, y, test_size=0.2, random_state=42)
poly_reg = LinearRegression()
poly_reg.fit(X_train_poly, y_train)
y_pred_poly = poly_reg.predict(X_test_poly)
print("R2 Polinomial:", r2_score(y_test, y_pred_poly))
print("RMSE Polinomial:", np.sqrt(mean_squared_error(y_test, y_pred_poly)))
6. Regularização: Ridge e Lasso
Modelos avançados de regressão podem sofrer overfitting, principalmente com features polinomiais. A regularização ajuda a reduzir esse risco.
# Ridge Regression
ridge = Ridge(alpha=1.0)
ridge.fit(X_train_poly, y_train)
y_pred_ridge = ridge.predict(X_test_poly)
# Lasso Regression
lasso = Lasso(alpha=0.1)
lasso.fit(X_train_poly, y_train)
y_pred_lasso = lasso.predict(X_test_poly)
print("R2 Ridge:", r2_score(y_test, y_pred_ridge))
print("R2 Lasso:", r2_score(y_test, y_pred_lasso))
7. Modelos baseados em árvores
Para relações complexas e interações não-lineares, algoritmos baseados em árvore como XGBoost podem ser extremamente eficazes:
import xgboost as xgb
xgb_model = xgb.XGBRegressor(objective='reg:squarederror', n_estimators=100)
xgb_model.fit(X_train, y_train)
y_pred_xgb = xgb_model.predict(X_test)
print("R2 XGBoost:", r2_score(y_test, y_pred_xgb))
Vantagens:
Não exige normalização ou padronização.
Captura relações complexas e interações automaticamente.
Altamente escalável para grandes volumes de dados.
8. Interpretação e Visualização
É importante não apenas prever, mas entender o impacto de cada variável:
coef_df = pd.DataFrame({'Feature': X.columns, 'Coeficiente': lin_reg.coef_})
print(coef_df)
sns.barplot(x='Coeficiente', y='Feature', data=coef_df)
plt.title('Importância das Variáveis')
plt.show()
Para modelos de árvore, bibliotecas como SHAP ou Eli5 podem fornecer interpretabilidade detalhada.
9. Boas práticas para regressão avançada
Sempre faça exploração e limpeza de dados antes de treinar modelos.
Teste diferentes transformações e interações de features.
Use cross-validation para validar a robustez do modelo.
Experimente regularização para reduzir overfitting.
Compare modelos lineares, polinomiais e baseados em árvore para escolher o melhor para o problema.
10. Conclusão
A regressão avançada em Python permite modelar relações complexas de forma eficiente, combinando modelos lineares, polinomiais, regularizados e baseados em árvore. Ao entender os dados, testar transformações, aplicar técnicas de regularização e interpretar os resultados, você pode construir modelos preditivos precisos e robustos, aplicáveis em finanças, vendas, saúde, engenharia e muito mais.
Com bibliotecas como Scikit-learn, Statsmodels e XGBoost, você tem todas as ferramentas necessárias para evoluir do básico ao avançado em regressão, extraindo insights profundos de seus dados.
Comentários
Postar um comentário