Regressão Multivariada - Área de Trampo

Expandindo Horizontes: O Conceito de Regressão Multivariada

A Regressão Linear Multivariada representa a evolução natural do modelo univariado no campo da aprendizagem de máquina. Enquanto a versão simples trabalha com apenas uma característica preditora, a abordagem multivariada incorpora múltiplas variáveis independentes simultaneamente. Esta expansão permite capturar a complexidade inerente aos fenômenos do mundo real, raramente explicados por um único fator isolado. Matematicamente, expressamos este modelo pela equação y = β₀ + β₁x₁ + β₂x₂ + … + βₙxₙ, onde cada β representa o peso ou coeficiente de cada variável preditora. Interpretar esses coeficientes torna-se uma tarefa fascinante, pois revelam o impacto específico de cada característica sobre o resultado final, mantendo as demais constantes. Para iniciantes, compreender esta expansão conceitual abre portas para análises muito mais ricas e próximas da realidade cotidiana.

Diferentemente do modelo simples, a regressão multivariada reconhece que múltiplos fatores geralmente influenciam um resultado. O preço de um imóvel, por exemplo, não depende apenas da metragem quadrada. Localização, número de quartos, idade da construção e proximidade do comércio também exercem influência significativa. Incorporar todas essas variáveis ao modelo produz previsões consideravelmente mais precisas. Durante o processo de aprendizado, o algoritmo ajusta os coeficientes buscando minimizar o erro entre valores previstos e reais. Esta otimização ocorre tipicamente através do método dos mínimos quadrados ordinários ou técnicas de gradiente descendente. A beleza deste processo reside na capacidade do modelo de aprender padrões complexos diretamente dos dados fornecidos.

Desafios Específicos da Abordagem Multivariada

Trabalhar com múltiplas variáveis introduz desafios que simplesmente não existiam na versão univariada. A multicolinearidade surge como um dos problemas mais frequentes e traiçoeiros neste contexto. Este fenômeno ocorre quando duas ou mais variáveis preditoras apresentam forte correlação entre si, confundindo o modelo e tornando os coeficientes instáveis e difíceis de interpretar. Imagine tentar prever o desempenho acadêmico usando horas de estudo e horas de sono como preditores. Estas variáveis provavelmente se correlacionam, pois alunos que dormem pouco podem estudar mais, criando uma relação complexa que o modelo precisa desvendar. Técnicas como o Fator de Inflação da Variância ajudam a diagnosticar este problema, permitindo decisões conscientes sobre quais variáveis manter ou remover.

Outro desafio significativo envolve a seleção das variáveis verdadeiramente relevantes para o modelo. Incluir preditores irrelevantes não apenas aumenta a complexidade desnecessariamente, como também pode reduzir a capacidade preditiva do algoritmo. Este fenômeno, conhecido como overfitting, ocorre quando o modelo se ajusta excessivamente aos dados de treinamento, perdendo a capacidade de generalizar para novas observações. Técnicas de regularização, como Ridge e Lasso, oferecem soluções elegantes para este dilema, penalizando coeficientes excessivamente grandes ou eliminando variáveis completamente irrelevantes. Para iniciantes, compreender estes desafios desde o início previne frustrações futuras e constrói uma base sólida para o aprendizado contínuo.

Aplicações Práticas e Interpretação de Resultados

As aplicações da regressão multivariada permeiam praticamente todas as áreas do conhecimento humano. No setor imobiliário, corretores utilizam estes modelos para avaliar propriedades considerando múltiplas características simultaneamente. Profissionais de marketing empregam a técnica para prever vendas com base em investimentos publicitários em diferentes canais, sazonalidade e condições econômicas. Na área da saúde, pesquisadores relacionam hábitos de vida, histórico familiar e marcadores genéticos à probabilidade de desenvolvimento de doenças. Cada uma destas aplicações demonstra a versatilidade e o poder deste instrumento analítico quando corretamente aplicado.

Interpretar os resultados de uma regressão multivariada exige atenção cuidadosa a múltiplos indicadores estatísticos. O R² ajustado informa a proporção da variabilidade explicada pelo modelo, considerando o número de variáveis incluídas. Os valores-p associados a cada coeficiente indicam a significância estatística de cada preditor individualmente. Intervalos de confiança fornecem uma faixa plausível para o verdadeiro valor de cada coeficiente na população. Analisar estes elementos em conjunto permite conclusões robustas e defensáveis. Decisões de negócio baseadas nestas análises tendem a ser mais acertadas, pois fundamentam-se em evidências concretas extraídas dos dados históricos. Esta abordagem transforma intuições subjetivas em conhecimento objetivo e acionável.

Preparação dos Dados e Pré-processamento

Antes de alimentar qualquer algoritmo multivariado, os dados exigem preparação cuidadosa e criteriosa. Variáveis medidas em escalas muito diferentes podem distorcer completamente os resultados, pois aquelas com magnitudes maiores dominariam indevidamente o processo de aprendizado. A normalização ou padronização resolve elegantemente este problema, colocando todas as características na mesma escala comparável. Valores ausentes também precisam de tratamento adequado, seja através da remoção das observações incompletas, seja pela imputação de valores estimados com base nas demais informações disponíveis. Estas decisões, embora pareçam meramente técnicas, carregam implicações profundas sobre a validade dos resultados obtidos.

Variáveis categóricas representam outro ponto crítico no pré-processamento para regressão multivariada. Diferentemente das variáveis numéricas, categorias como “bairro” ou “tipo de imóvel” não podem ser inseridas diretamente no modelo. Técnicas como one-hot encoding transformam estas categorias em múltiplas colunas binárias, cada uma indicando a presença ou ausência de determinada característica. Esta expansão dimensional aumenta significativamente o número de preditores, exigindo atenção redobrada aos desafios mencionados anteriormente. Outras transformações, como a criação de termos de interação entre variáveis, podem capturar efeitos sinérgicos que preditores isolados não conseguem representar. Dominar estas técnicas de preparação separa analistas competentes de profissionais verdadeiramente excepcionais.

Regressão Linear Múltipla (Multivariável)

# ============================================
# REGRESSÃO LINEAR MÚLTIPLA - PREÇO DE IMÓVEIS
# ============================================

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
from sklearn.pipeline import make_pipeline

# Configuração para visualização
plt.style.use('seaborn-v0_8-darkgrid')
sns.set_palette("husl")


# ============================================
# 1. CRIANDO DADOS SINTÉTICOS REALISTAS
# ============================================
np.random.seed(42)
n_amostras = 1000

# Features (variáveis independentes)
area = np.random.normal(120, 40, n_amostras)  # área em m²
quartos = np.random.randint(1, 6, n_amostras)  # número de quartos
banheiros = np.random.randint(1, 4, n_amostras)  # número de banheiros
idade = np.random.randint(0, 50, n_amostras)  # idade do imóvel em anos
andares = np.random.randint(1, 3, n_amostras)  # número de andares
garagem = np.random.randint(0, 3, n_amostras)  # vagas de garagem

# Criando ruído aleatório
ruido = np.random.normal(0, 50000, n_amostras)

# Target (variável dependente) - PREÇO
# Fórmula: preço = 5000*area + 20000*quartos + 15000*banheiros - 2000*idade + 30000*garagem
preco = (5000 * area +
         20000 * quartos +
         15000 * banheiros -
         2000 * idade +
         30000 * garagem +
         ruido)

# Garantindo preços positivos
preco = np.abs(preco)

# Criando DataFrame
df = pd.DataFrame({
    'area': area,
    'quartos': quartos,
    'banheiros': banheiros,
    'idade': idade,
    'andares': andares,
    'garagem': garagem,
    'preco': preco
})

print("=" * 60)
print("DATASET DE IMÓVEIS")
print("=" * 60)
print(df.head())
print(f"\nShape: {df.shape}")
print(f"\nInformações das variáveis:")
print(df.describe())

# ============================================

# REGRESSÃO LINEAR MÚLTIPLA - PREÇO DE IMÓVEIS

# ============================================

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error

from sklearn.pipeline import make_pipeline

# Configuração para visualização

plt.style.use('seaborn-v0_8-darkgrid')

sns.set_palette("husl")

# ============================================

# 1. CRIANDO DADOS SINTÉTICOS REALISTAS

# ============================================

np.random.seed(42)

n_amostras = 1000

# Features (variáveis independentes)

area = np.random.normal(120, 40, n_amostras) # área em m²

quartos = np.random.randint(1, 6, n_amostras) # número de quartos

banheiros = np.random.randint(1, 4, n_amostras) # número de banheiros

idade = np.random.randint(0, 50, n_amostras) # idade do imóvel em anos

andares = np.random.randint(1, 3, n_amostras) # número de andares

garagem = np.random.randint(0, 3, n_amostras) # vagas de garagem

# Criando ruído aleatório

ruido = np.random.normal(0, 50000, n_amostras)

# Target (variável dependente) - PREÇO

# Fórmula: preço = 5000*area + 20000*quartos + 15000*banheiros - 2000*idade + 30000*garagem

preco = (5000 * area +

20000 * quartos +

15000 * banheiros -

2000 * idade +

30000 * garagem +

ruido)

# Garantindo preços positivos

preco = np.abs(preco)

# Criando DataFrame

df = pd.DataFrame({

'area': area,

'quartos': quartos,

'banheiros': banheiros,

'idade': idade,

'andares': andares,

'garagem': garagem,

'preco': preco

})

print("=" * 60)

print("DATASET DE IMÓVEIS")

print("=" * 60)

print(df.head())

print(f"\nShape: {df.shape}")

print(f"\nInformações das variáveis:")

print(df.describe())

# ============================================
# 2. ANÁLISE EXPLORATÓRIA
# ============================================
fig, axes = plt.subplots(2, 3, figsize=(15, 10))

features = ['area', 'quartos', 'banheiros', 'idade', 'andares', 'garagem']
for i, feat in enumerate(features):
    row, col = i // 3, i % 3
    axes[row, col].scatter(df[feat], df['preco'], alpha=0.3)
    axes[row, col].set_xlabel(feat)
    axes[row, col].set_ylabel('preço')
    axes[row, col].set_title(f'{feat} vs Preço')
    axes[row, col].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Matriz de correlação
plt.figure(figsize=(10, 8))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm', center=0, fmt='.2f')
plt.title('Matriz de Correlação')
plt.show()

# ============================================

# 2. ANÁLISE EXPLORATÓRIA

# ============================================

fig, axes = plt.subplots(2, 3, figsize=(15, 10))

features = ['area', 'quartos', 'banheiros', 'idade', 'andares', 'garagem']

for i, feat in enumerate(features):

row, col = i // 3, i % 3

axes[row, col].scatter(df[feat], df['preco'], alpha=0.3)

axes[row, col].set_xlabel(feat)

axes[row, col].set_ylabel('preço')

axes[row, col].set_title(f'{feat} vs Preço')

axes[row, col].grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Matriz de correlação

plt.figure(figsize=(10, 8))

sns.heatmap(df.corr(), annot=True, cmap='coolwarm', center=0, fmt='.2f')

plt.title('Matriz de Correlação')

plt.show()

# ============================================
# 3. PREPARAÇÃO DOS DADOS
# ============================================
X = df.drop('preco', axis=1)  # Features
y = df['preco']                 # Target

# 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
)

print("\n" + "=" * 60)
print("DIVISÃO DOS DADOS")
print("=" * 60)
print(f"Tamanho do treino: {X_train.shape}")
print(f"Tamanho do teste: {X_test.shape}")

# ============================================

# 3. PREPARAÇÃO DOS DADOS

# ============================================

X = df.drop('preco', axis=1) # Features

y = df['preco'] # Target

# 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

)

print("\n" + "=" * 60)

print("DIVISÃO DOS DADOS")

print("=" * 60)

print(f"Tamanho do treino: {X_train.shape}")

print(f"Tamanho do teste: {X_test.shape}")

# ============================================
# 4. MODELO 1: SEM NORMALIZAÇÃO
# ============================================
modelo_sem_norm = LinearRegression()
modelo_sem_norm.fit(X_train, y_train)

# Predições
y_pred_train_sem = modelo_sem_norm.predict(X_train)
y_pred_test_sem = modelo_sem_norm.predict(X_test)

# ============================================

# 4. MODELO 1: SEM NORMALIZAÇÃO

# ============================================

modelo_sem_norm = LinearRegression()

modelo_sem_norm.fit(X_train, y_train)

# Predições

y_pred_train_sem = modelo_sem_norm.predict(X_train)

y_pred_test_sem = modelo_sem_norm.predict(X_test)

# ============================================
# 5. MODELO 2: COM NORMALIZAÇÃO
# ============================================
modelo_com_norm = make_pipeline(
    StandardScaler(),
    LinearRegression()
)
modelo_com_norm.fit(X_train, y_train)

# Predições
y_pred_train_com = modelo_com_norm.predict(X_train)
y_pred_test_com = modelo_com_norm.predict(X_test)

# ============================================

# 5. MODELO 2: COM NORMALIZAÇÃO

# ============================================

modelo_com_norm = make_pipeline(

StandardScaler(),

LinearRegression()

)

modelo_com_norm.fit(X_train, y_train)

# Predições

y_pred_train_com = modelo_com_norm.predict(X_train)

y_pred_test_com = modelo_com_norm.predict(X_test)

# ============================================
# 6. AVALIAÇÃO DOS MODELOS
# ============================================
def avaliar_modelo(y_true, y_pred, nome_modelo, conjunto):
    """Função para avaliar métricas do modelo"""
    r2 = r2_score(y_true, y_pred)
    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
    mae = mean_absolute_error(y_true, y_pred)
    mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100

    print(f"\n{conjunto} - {nome_modelo}:")
    print(f"  R² Score: {r2:.4f}")
    print(f"  RMSE: R$ {rmse:,.2f}")
    print(f"  MAE: R$ {mae:,.2f}")
    print(f"  MAPE: {mape:.2f}%")

    return r2, rmse, mae, mape

print("\n" + "=" * 60)
print("AVALIAÇÃO DOS MODELOS")
print("=" * 60)

# Avaliando modelos
print("\n📊 MODELO SEM NORMALIZAÇÃO:")
r2_train_sem, rmse_train_sem, mae_train_sem, mape_train_sem = avaliar_modelo(
    y_train, y_pred_train_sem, "Linear Regression", "TREINO"
)
r2_test_sem, rmse_test_sem, mae_test_sem, mape_test_sem = avaliar_modelo(
    y_test, y_pred_test_sem, "Linear Regression", "TESTE"
)

print("\n📊 MODELO COM NORMALIZAÇÃO:")
r2_train_com, rmse_train_com, mae_train_com, mape_train_com = avaliar_modelo(
    y_train, y_pred_train_com, "Linear Regression (com scaler)", "TREINO"
)
r2_test_com, rmse_test_com, mae_test_com, mape_test_com = avaliar_modelo(
    y_test, y_pred_test_com, "Linear Regression (com scaler)", "TESTE"
)

# ============================================

# 6. AVALIAÇÃO DOS MODELOS

# ============================================

def avaliar_modelo(y_true, y_pred, nome_modelo, conjunto):

"""Função para avaliar métricas do modelo"""

r2 = r2_score(y_true, y_pred)

rmse = np.sqrt(mean_squared_error(y_true, y_pred))

mae = mean_absolute_error(y_true, y_pred)

mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100

print(f"\n{conjunto} - {nome_modelo}:")

print(f" R² Score: {r2:.4f}")

print(f" RMSE: R$ {rmse:,.2f}")

print(f" MAE: R$ {mae:,.2f}")

print(f" MAPE: {mape:.2f}%")

return r2, rmse, mae, mape

print("\n" + "=" * 60)

print("AVALIAÇÃO DOS MODELOS")

print("=" * 60)

# Avaliando modelos

print("\n📊 MODELO SEM NORMALIZAÇÃO:")

r2_train_sem, rmse_train_sem, mae_train_sem, mape_train_sem = avaliar_modelo(

y_train, y_pred_train_sem, "Linear Regression", "TREINO"

)

r2_test_sem, rmse_test_sem, mae_test_sem, mape_test_sem = avaliar_modelo(

y_test, y_pred_test_sem, "Linear Regression", "TESTE"

)

print("\n📊 MODELO COM NORMALIZAÇÃO:")

r2_train_com, rmse_train_com, mae_train_com, mape_train_com = avaliar_modelo(

y_train, y_pred_train_com, "Linear Regression (com scaler)", "TREINO"

)

r2_test_com, rmse_test_com, mae_test_com, mape_test_com = avaliar_modelo(

y_test, y_pred_test_com, "Linear Regression (com scaler)", "TESTE"

)

# ============================================
# 7. COMPARAÇÃO DE COEFICIENTES
# ============================================
# Coeficientes do modelo sem normalização
coef_sem_norm = modelo_sem_norm.coef_
intercept_sem_norm = modelo_sem_norm.intercept_

# Coeficientes do modelo com normalização (na escala original)
scaler = modelo_com_norm.named_steps['standardscaler']
lr = modelo_com_norm.named_steps['linearregression']
coef_com_norm_original = lr.coef_ / scaler.scale_
intercept_com_norm_original = lr.intercept_ - np.sum(lr.coef_ * scaler.mean_ / scaler.scale_)

# DataFrame comparativo
df_coeficientes = pd.DataFrame({
    'Feature': X.columns,
    'Coef (sem norm)': coef_sem_norm,
    'Coef (com norm - escala original)': coef_com_norm_original,
    'Diferença (%)': ((coef_com_norm_original - coef_sem_norm) / coef_sem_norm * 100)
})

print("\n" + "=" * 60)
print("COMPARAÇÃO DE COEFICIENTES")
print("=" * 60)
print(df_coeficientes.to_string())
print(f"\nIntercept (sem norm): R$ {intercept_sem_norm:,.2f}")
print(f"Intercept (com norm - escala original): R$ {intercept_com_norm_original:,.2f}")

# ============================================

# 7. COMPARAÇÃO DE COEFICIENTES

# ============================================

# Coeficientes do modelo sem normalização

coef_sem_norm = modelo_sem_norm.coef_

intercept_sem_norm = modelo_sem_norm.intercept_

# Coeficientes do modelo com normalização (na escala original)

scaler = modelo_com_norm.named_steps['standardscaler']

lr = modelo_com_norm.named_steps['linearregression']

coef_com_norm_original = lr.coef_ / scaler.scale_

intercept_com_norm_original = lr.intercept_ - np.sum(lr.coef_ * scaler.mean_ / scaler.scale_)

# DataFrame comparativo

df_coeficientes = pd.DataFrame({

'Feature': X.columns,

'Coef (sem norm)': coef_sem_norm,

'Coef (com norm - escala original)': coef_com_norm_original,

'Diferença (%)': ((coef_com_norm_original - coef_sem_norm) / coef_sem_norm * 100)

})

print("\n" + "=" * 60)

print("COMPARAÇÃO DE COEFICIENTES")

print("=" * 60)

print(df_coeficientes.to_string())

print(f"\nIntercept (sem norm): R$ {intercept_sem_norm:,.2f}")

print(f"Intercept (com norm - escala original): R$ {intercept_com_norm_original:,.2f}")

# ============================================
# 8. VISUALIZAÇÃO DOS RESULTADOS
# ============================================
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Gráfico 1: Real vs Predito (Treino)
axes[0, 0].scatter(y_train, y_pred_train_sem, alpha=0.5, label='Sem norm')
axes[0, 0].scatter(y_train, y_pred_train_com, alpha=0.5, label='Com norm')
axes[0, 0].plot([y_train.min(), y_train.max()], [y_train.min(), y_train.max()],
                'r--', linewidth=2, label='Ideal')
axes[0, 0].set_xlabel('Preço Real')
axes[0, 0].set_ylabel('Preço Predito')
axes[0, 0].set_title('Treino: Real vs Predito')
axes[0, 0].legend()
axes[0, 0].grid(True, alpha=0.3)

# Gráfico 2: Real vs Predito (Teste)
axes[0, 1].scatter(y_test, y_pred_test_sem, alpha=0.5, label='Sem norm')
axes[0, 1].scatter(y_test, y_pred_test_com, alpha=0.5, label='Com norm')
axes[0, 1].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()],
                'r--', linewidth=2, label='Ideal')
axes[0, 1].set_xlabel('Preço Real')
axes[0, 1].set_ylabel('Preço Predito')
axes[0, 1].set_title('Teste: Real vs Predito')
axes[0, 1].legend()
axes[0, 1].grid(True, alpha=0.3)

# Gráfico 3: Resíduos (Teste)
residuos_sem = y_test - y_pred_test_sem
residuos_com = y_test - y_pred_test_com
axes[1, 0].scatter(y_pred_test_sem, residuos_sem, alpha=0.5, label='Sem norm')
axes[1, 0].scatter(y_pred_test_com, residuos_com, alpha=0.5, label='Com norm')
axes[1, 0].axhline(y=0, color='r', linestyle='--', linewidth=2)
axes[1, 0].set_xlabel('Preço Predito')
axes[1, 0].set_ylabel('Resíduos')
axes[1, 0].set_title('Resíduos vs Predito')
axes[1, 0].legend()
axes[1, 0].grid(True, alpha=0.3)

# Gráfico 4: Comparação de Coeficientes
x = np.arange(len(df_coeficientes))
width = 0.35
axes[1, 1].bar(x - width/2, df_coeficientes['Coef (sem norm)'], width, label='Sem norm')
axes[1, 1].bar(x + width/2, df_coeficientes['Coef (com norm - escala original)'],
               width, label='Com norm')
axes[1, 1].set_xlabel('Features')
axes[1, 1].set_ylabel('Coeficientes')
axes[1, 1].set_title('Comparação de Coeficientes')
axes[1, 1].set_xticks(x)
axes[1, 1].set_xticklabels(df_coeficientes['Feature'], rotation=45)
axes[1, 1].legend()
axes[1, 1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# ============================================

# 8. VISUALIZAÇÃO DOS RESULTADOS

# ============================================

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Gráfico 1: Real vs Predito (Treino)

axes[0, 0].scatter(y_train, y_pred_train_sem, alpha=0.5, label='Sem norm')

axes[0, 0].scatter(y_train, y_pred_train_com, alpha=0.5, label='Com norm')

axes[0, 0].plot([y_train.min(), y_train.max()], [y_train.min(), y_train.max()],

'r--', linewidth=2, label='Ideal')

axes[0, 0].set_xlabel('Preço Real')

axes[0, 0].set_ylabel('Preço Predito')

axes[0, 0].set_title('Treino: Real vs Predito')

axes[0, 0].legend()

axes[0, 0].grid(True, alpha=0.3)

# Gráfico 2: Real vs Predito (Teste)

axes[0, 1].scatter(y_test, y_pred_test_sem, alpha=0.5, label='Sem norm')

axes[0, 1].scatter(y_test, y_pred_test_com, alpha=0.5, label='Com norm')

axes[0, 1].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()],

'r--', linewidth=2, label='Ideal')

axes[0, 1].set_xlabel('Preço Real')

axes[0, 1].set_ylabel('Preço Predito')

axes[0, 1].set_title('Teste: Real vs Predito')

axes[0, 1].legend()

axes[0, 1].grid(True, alpha=0.3)

# Gráfico 3: Resíduos (Teste)

residuos_sem = y_test - y_pred_test_sem

residuos_com = y_test - y_pred_test_com

axes[1, 0].scatter(y_pred_test_sem, residuos_sem, alpha=0.5, label='Sem norm')

axes[1, 0].scatter(y_pred_test_com, residuos_com, alpha=0.5, label='Com norm')

axes[1, 0].axhline(y=0, color='r', linestyle='--', linewidth=2)

axes[1, 0].set_xlabel('Preço Predito')

axes[1, 0].set_ylabel('Resíduos')

axes[1, 0].set_title('Resíduos vs Predito')

axes[1, 0].legend()

axes[1, 0].grid(True, alpha=0.3)

# Gráfico 4: Comparação de Coeficientes

x = np.arange(len(df_coeficientes))

width = 0.35

axes[1, 1].bar(x - width/2, df_coeficientes['Coef (sem norm)'], width, label='Sem norm')

axes[1, 1].bar(x + width/2, df_coeficientes['Coef (com norm - escala original)'],

width, label='Com norm')

axes[1, 1].set_xlabel('Features')

axes[1, 1].set_ylabel('Coeficientes')

axes[1, 1].set_title('Comparação de Coeficientes')

axes[1, 1].set_xticks(x)

axes[1, 1].set_xticklabels(df_coeficientes['Feature'], rotation=45)

axes[1, 1].legend()

axes[1, 1].grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# ============================================
# 9. IMPORTÂNCIA DAS FEATURES (APÓS NORMALIZAÇÃO)
# ============================================
importancia = np.abs(lr.coef_)
indices = np.argsort(importancia)[::-1]

plt.figure(figsize=(10, 6))
plt.bar(range(len(importancia)), importancia[indices])
plt.xticks(range(len(importancia)), [X.columns[i] for i in indices], rotation=45)
plt.xlabel('Features')
plt.ylabel('Importância |coeficiente|')
plt.title('Importância das Features (após normalização)')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# ============================================

# 9. IMPORTÂNCIA DAS FEATURES (APÓS NORMALIZAÇÃO)

# ============================================

importancia = np.abs(lr.coef_)

indices = np.argsort(importancia)[::-1]

plt.figure(figsize=(10, 6))

plt.bar(range(len(importancia)), importancia[indices])

plt.xticks(range(len(importancia)), [X.columns[i] for i in indices], rotation=45)

plt.xlabel('Features')

plt.ylabel('Importância |coeficiente|')

plt.title('Importância das Features (após normalização)')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# ============================================
# 10. EXEMPLO DE PREDIÇÃO
# ============================================
print("\n" + "=" * 60)
print("EXEMPLO DE PREDIÇÃO")
print("=" * 60)

# Criando um novo imóvel
novo_imovel = pd.DataFrame({
    'area': [150],        # 150 m²
    'quartos': [3],       # 3 quartos
    'banheiros': [2],     # 2 banheiros
    'idade': [5],         # 5 anos
    'andares': [1],       # 1 andar
    'garagem': [2]        # 2 vagas
})

# Predição com ambos os modelos
preco_pred_sem = modelo_sem_norm.predict(novo_imovel)[0]
preco_pred_com = modelo_com_norm.predict(novo_imovel)[0]

print("\n🏠 NOVO IMÓVEL:")
for col in novo_imovel.columns:
    print(f"  {col}: {novo_imovel[col].values[0]}")

print(f"\n💰 PREÇO PREDITO:")
print(f"  Sem normalização: R$ {preco_pred_sem:,.2f}")
print(f"  Com normalização: R$ {preco_pred_com:,.2f}")
print(f"  Diferença: R$ {preco_pred_com - preco_pred_sem:,.2f}")

# ============================================

# 10. EXEMPLO DE PREDIÇÃO

# ============================================

print("\n" + "=" * 60)

print("EXEMPLO DE PREDIÇÃO")

print("=" * 60)

# Criando um novo imóvel

novo_imovel = pd.DataFrame({

'area': [150], # 150 m²

'quartos': [3], # 3 quartos

'banheiros': [2], # 2 banheiros

'idade': [5], # 5 anos

'andares': [1], # 1 andar

'garagem': [2] # 2 vagas

})

# Predição com ambos os modelos

preco_pred_sem = modelo_sem_norm.predict(novo_imovel)[0]

preco_pred_com = modelo_com_norm.predict(novo_imovel)[0]

print("\n🏠 NOVO IMÓVEL:")

for col in novo_imovel.columns:

print(f" {col}: {novo_imovel[col].values[0]}")

print(f"\n💰 PREÇO PREDITO:")

print(f" Sem normalização: R$ {preco_pred_sem:,.2f}")

print(f" Com normalização: R$ {preco_pred_com:,.2f}")

print(f" Diferença: R$ {preco_pred_com - preco_pred_sem:,.2f}")

# ============================================
# 11. VALIDAÇÃO CRUZADA (opcional)
# ============================================
from sklearn.model_selection import cross_val_score

print("\n" + "=" * 60)
print("VALIDAÇÃO CRUZADA (5-fold)")
print("=" * 60)

# Validação cruzada - sem normalização
scores_sem = cross_val_score(modelo_sem_norm, X, y, cv=5, scoring='r2')
print(f"\nSem normalização:")
print(f"  R² médio: {scores_sem.mean():.4f} (+/- {scores_sem.std() * 2:.4f})")

# Validação cruzada - com normalização
modelo_cv = make_pipeline(StandardScaler(), LinearRegression())
scores_com = cross_val_score(modelo_cv, X, y, cv=5, scoring='r2')
print(f"\nCom normalização:")
print(f"  R² médio: {scores_com.mean():.4f} (+/- {scores_com.std() * 2:.4f})")

Expandindo Horizontes: O Conceito de Regressão Multivariada

Desafios Específicos da Abordagem Multivariada

Aplicações Práticas e Interpretação de Resultados

Preparação dos Dados e Pré-processamento

Regressão Linear Múltipla (Multivariável)

Deixe um comentário Cancelar resposta