Regressão Multivariada

01/03/2026 Por antonino

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})")

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

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

Regressão Linear Univariada

01/03/2026 Por antonino

Dona de casa selecionando uma amostra da sopa que ela preparou

Regressão Linear Univariada

Entendendo o Cenário Ideal: A Relação entre Duas Variáveis

A Regressão Linear Univariada representa uma ferramenta fundamental no universo da aprendizagem de máquina. Para qualquer iniciante, saber quando aplicá-la corretamente torna-se o primeiro passo rumo a modelos preditivos eficazes. Em essência, recorremos a esta técnica quando precisamos prever um valor numérico contínuo partindo de uma única característica. A própria palavra “univariada” já revela seu significado: “uma variável”. Dessa forma, o cenário ideal surge quando identificamos uma relação linear entre esses dois elementos, ou seja, quando as mudanças na variável preditora provocam mudanças proporcionais na variável alvo.

O exemplo clássico envolve a relação entre o tamanho de uma casa e seu preço de venda. Intuitivamente, todos sabemos que casas maiores tendem a alcançar preços mais elevados. Neste caso, a variável independente corresponde ao tamanho, enquanto a dependente representa o preço. A regressão, então, encontrará a melhor linha reta para representar essa tendência central. A equação y = mx + b descreve perfeitamente essa linha, onde m indica o coeficiente angular. Podemos citar ainda outros exemplos igualmente didáticos, como prever a pontuação de um aluno a partir de suas horas de estudo. Da mesma forma, estimar o consumo de combustível de um carro considerando sua velocidade média também se encaixa perfeitamente neste contexto.

Os Pressupostos que Garantem a Confiabilidade do Modelo

Precisamos compreender profundamente as condições que tornam a Regressão Linear Univariada uma escolha realmente adequada. Acima de tudo, a existência de uma relação aproximadamente linear entre as variáveis surge como o pressuposto mais importante. Felizmente, podemos verificar essa condição facilmente através de um gráfico de dispersão. Caso os pontos não se organizem em torno de uma linha reta, mas sim formem uma curva, o modelo certamente produzirá previsões imprecisas. Por exemplo, ninguém deveria usar este modelo para prever a aceleração de um foguete baseando-se apenas no tempo, pois essa relação claramente não segue um padrão linear.

Além disso, a independência das observações merece atenção especial. Cada ponto de dado não pode, sob hipótese alguma, influenciar o outro. Medições repetidas da mesma casa ao longo do tempo violariam completamente este princípio. Outro aspecto fundamental envolve a homocedasticidade, que significa manter a variância dos erros constante para todos os valores da variável preditora. Quando observamos a dispersão aumentando progressivamente, o modelo perde sua confiabilidade. Vale ressaltar que a multicolinearidade não se aplica aqui, pois trabalhamos com apenas uma variável preditora, o que naturalmente torna a validação mais simples e direta.

A Força da Simplicidade: Quando Começar por Aqui

A simplicidade característica da Regressão Linear Univariada representa simultaneamente sua maior força e sua principal limitação. Portanto, devemos utilizá-la quando a realidade se mostra verdadeiramente simples e depende de um único fator determinante. Este modelo funciona admiravelmente bem como ponto de partida em qualquer projeto analítico. Mesmo quando almejamos construir modelos complexos posteriormente, começar com uma análise univariada revela-se extremamente recomendável. Através dela, obtemos insights valiosos sobre a direção e a intensidade do relacionamento entre os dados estudados.

Esta abordagem inicial certamente ajuda a orientar a construção de modelos mais sofisticados no futuro. Padrões importantes emergem naturalmente durante esta fase exploratória, podendo ser explorados com maior profundidade nas etapas seguintes. Ignorar os pressupostos fundamentais, por outro lado, pode nos levar a conclusões completamente equivocadas. Por isso, entender profundamente o “quando usar” mostra-se tão crucial quanto dominar o “como usar”. A interpretabilidade figura como uma vantagem notável oferecida por este modelo. Consequentemente, explicar como uma variável influencia diretamente o resultado final torna-se uma tarefa simples e intuitiva, característica especialmente valiosa em contextos de negócios e processos decisórios baseados em dados.

Carregando o conjunto de dados

import pandas as pd
# dataset: https://www.kaggle.com/datasets/tmcketterick/heights-and-weights
df = pd.read_csv('/content/regressao-linear-univariada.csv')
"""
Exibindo amostra aleatória de 5 linhas para visualização inicial
"""
df.sample(5)

import pandas as pd

# dataset: https://www.kaggle.com/datasets/tmcketterick/heights-and-weights

df = pd.read_csv('/content/regressao-linear-univariada.csv')

"""

Exibindo amostra aleatória de 5 linhas para visualização inicial

"""

df.sample(5)

Verificando os tipos de dados das colunas

df.dtypes

df.dtypes

Analisando a estrutura do dataset (número de linhas e colunas)

df.shape

df.shape

Estatísticas descritivas básicas do dataset

df.describe()

1	df.describe()

Gráfico 01

import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(12,8))
plt.scatter(df['Height'],df['Weight'])
plt.xlabel('Height')
plt.ylabel('Weight')

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(12,8))

plt.scatter(df['Height'],df['Weight'])

plt.xlabel('Height')

plt.ylabel('Weight')

Separação em TREINO e TESTE

"""
Executamos train_test_split para dividir o conjunto de dados em dois conjuntos,
variáveis independentes (X) e dependentes (Y).
"""
from sklearn.model_selection import train_test_split

X = df[['Weight']]
Y = df['Height']

"""
Especificamos test_size=0.4, isto é, o conjunto de teste será criado com 40% do conjunto de dados,
ficando os 60% restantes para o conjunto de treinamento.
"""
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.4)

"""

Executamos train_test_split para dividir o conjunto de dados em dois conjuntos,

variáveis independentes (X) e dependentes (Y).

"""

from sklearn.model_selection import train_test_split

X = df[['Weight']]

Y = df['Height']

"""

Especificamos test_size=0.4, isto é, o conjunto de teste será criado com 40% do conjunto de dados,

ficando os 60% restantes para o conjunto de treinamento.

"""

x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.4)

Exibindo os parâmetros do modelo treinado

from matplotlib.colors import Normalize
from sklearn.linear_model import LinearRegression
linear_model = LinearRegression().fit(x_train, y_train)
print("Modelo Linear Simples: Intercept = {:.5}".format(linear_model.intercept_))
print("Modelo Linear Simples: Coefficient = {:.5}".format(linear_model.coef_[0]))
print("Modelo Linear Simples: Weight = {:.5} + {:.5}(Height)".format(linear_model.intercept_, linear_model.coef_[0]))

from matplotlib.colors import Normalize

from sklearn.linear_model import LinearRegression

linear_model = LinearRegression().fit(x_train, y_train)

print("Modelo Linear Simples: Intercept = {:.5}".format(linear_model.intercept_))

print("Modelo Linear Simples: Coefficient = {:.5}".format(linear_model.coef_[0]))

print("Modelo Linear Simples: Weight = {:.5} + {:.5}(Height)".format(linear_model.intercept_, linear_model.coef_[0]))

Teste

"""
Treinamento do modelo linear.
"""
print('Train score:',linear_model.score(x_train,y_train))

y_pred = linear_model.predict(x_test)
from sklearn.metrics import r2_score
"""
Teste e avaliação do modelo linear.
"""
print('Test score:',r2_score(y_test,y_pred))

"""

Treinamento do modelo linear.

"""

print('Train score:',linear_model.score(x_train,y_train))

y_pred = linear_model.predict(x_test)

from sklearn.metrics import r2_score

"""

Teste e avaliação do modelo linear.

"""

print('Test score:',r2_score(y_test,y_pred))

Grafico 02

fig, ax = plt.subplots(figsize=(12,8))

plt.scatter(x_test, y_test)
plt.plot(x_test, y_pred, color='red')
plt.xlabel('Height')
plt.ylabel('Weight')
"""
Gráfico do modelo linear e conjunto de teste.
"""
plt.show()

fig, ax = plt.subplots(figsize=(12,8))

plt.scatter(x_test, y_test)

plt.plot(x_test, y_pred, color='red')

plt.xlabel('Height')

plt.ylabel('Weight')

"""

Gráfico do modelo linear e conjunto de teste.

"""

plt.show()

Avaliação

from sklearn.linear_model import LinearRegression
linear_model = LinearRegression().fit(x_train, y_train)
print("Modelo Linear Simples: Intercept = {:.5}".format(linear_model.intercept_))
print("Modelo Linear Simples: Coefficient = {:.5}".format(linear_model.coef_[0]))
print("Modelo Linear Simples: Weight = {:.5} + {:.5}(Height)".format(linear_model.intercept_, linear_model.coef_[0]))

"""
Treinamento do modelo linear com o novo conjunto.
"""
print('Training score: ', linear_model.score(x_train,y_train))

from sklearn.linear_model import LinearRegression

linear_model = LinearRegression().fit(x_train, y_train)

print("Modelo Linear Simples: Intercept = {:.5}".format(linear_model.intercept_))

print("Modelo Linear Simples: Coefficient = {:.5}".format(linear_model.coef_[0]))

print("Modelo Linear Simples: Weight = {:.5} + {:.5}(Height)".format(linear_model.intercept_, linear_model.coef_[0]))

"""

Treinamento do modelo linear com o novo conjunto.

"""

print('Training score: ', linear_model.score(x_train,y_train))

Realizando previsões no conjunto de teste

y_pred = linear_model.predict(x_test)
from sklearn.metrics import r2_score
"""
Avaliação do novo modelo.
Comparação entre valores reais e previsões do modelo
Medida de quão bem o modelo generaliza para dados não vistos
"""
print('Score no conjunto de teste (R²):', r2_score(y_test,y_pred))

y_pred = linear_model.predict(x_test)

from sklearn.metrics import r2_score

"""

Avaliação do novo modelo.

Comparação entre valores reais e previsões do modelo

Medida de quão bem o modelo generaliza para dados não vistos

"""

print('Score no conjunto de teste (R²):', r2_score(y_test,y_pred))

Visualização dos resultados

fig, ax = plt.subplots(figsize=(12,8))

plt.scatter(x_test, y_test)
plt.plot(x_test, y_pred, color='r')

plt.xlabel('Height')
plt.ylabel('Weight')
plt.show()

fig, ax = plt.subplots(figsize=(12,8))

plt.scatter(x_test, y_test)

plt.plot(x_test, y_pred, color='r')

plt.xlabel('Height')

plt.ylabel('Weight')

plt.show()