antonino, Autor em Área de Trampo

Regressão Linear Regularizada (Ridg, Lasso e Elastic Net)

23/05/202623/03/2026 Por antonino

O que é regressão linear e por que regularizar?

Primeiramente, imagine desenhar uma linha reta entre vários pontos. Por conseguinte, essa linha tenta prever um valor (como o preço de uma casa). Esse método chama-se regressão linear simples. Contudo, dados reais costumam ser bagunçados e cheios de variáveis. Assim, o modelo pode ficar complexo demais para os dados. Esse problema é conhecido como overfitting (sobreajuste). Para evitar isso, usamos técnicas de regularização. Dessa forma, elas aplicam “punições” aos coeficientes do modelo. Além disso, o modelo fica mais simples e generalizável. Três métodos populares são Ridge, Lasso e Elastic Net. Cada um age de maneira diferente nos coeficientes. Especialistas usam esses métodos em aprendizado de máquina. Seu principal benefício é melhorar previsões em novos dados. Portanto, a regularização é essencial para modelos confiáveis.

Ridge: encolhendo coeficientes sem zerar

Ridge é a primeira técnica que vamos explorar. Ela adiciona uma penalidade ao quadrado dos coeficientes. Os profissionais chamam essa penalidade de norma L2. O objetivo é encolher todos os coeficientes, mas sem zerá-los. Assim, nenhuma variável sai completamente do modelo. Isso é útil quando todas as variáveis importam um pouco. Por exemplo, dados genéticos ou de sensores se beneficiam disso. A força da penalidade depende de um parâmetro (alpha). Consequentemente, alpha maior produz coeficientes menores. Isso resulta em modelo mais simples e robusto. Uma desvantagem é que Ridge mantém variáveis irrelevantes. Elas ficam perto de zero, mas não exatamente zero. Portanto, isso pode dificultar a interpretação do modelo final. Ainda assim, Ridge evita overfitting severo com eficiência. Muitas situações práticas se beneficiam dessa abordagem.

Lasso: escolhendo variáveis importantes

Lasso usa uma penalidade diferente, chamada norma L1. Ela soma os valores absolutos dos coeficientes. O resultado é que alguns coeficientes viram exatamente zero. Desse modo, Lasso faz seleção automática de variáveis. Variáveis zeradas saem do modelo final completamente. Isso torna o modelo mais simples e fácil de explicar. Por exemplo, marketing com 100 possíveis canais de venda. Lasso descobre quais canais realmente influenciam as vendas. Contudo, Lasso tem uma limitação importante. Se duas variáveis forem muito correlacionadas, ele escolhe uma. A outra variável fica zerada, mesmo que ambas sejam úteis. Além disso, poucos dados podem deixar Lasso instável. A escolha do alpha também exige cuidado e testes. Apesar disso, Lasso é muito usado em dados de alta dimensão.

Elastic Net: o melhor dos dois mundos

Elastic Net combina Ridge e Lasso em um só método. Sua penalidade mistura norma L1 e norma L2. Dois parâmetros controlam essa mistura: alpha e l1ratio. O alpha controla a força total da regularização. Já o l1ratio decide quanto de L1 versus L2 usar. Quando l1ratio é 1, Elastic Net vira Lasso puro. Quando l1ratio é 0, Elastic Net vira Ridge puro. Valores intermediários trazem benefícios de ambos. Por exemplo, ele encolhe coeficientes como Ridge. Mas também zera variáveis menos importantes como Lasso. Além disso, Elastic Net funciona bem com variáveis correlacionadas. Ele mantém grupos de variáveis relevantes juntos normalmente. Por essa razão, os especialistas preferem esse método. Em muitos projetos, Elastic Net supera Ridge e Lasso. Portanto, sua flexibilidade representa uma grande vantagem prática.

Como aplicar esses métodos na prática

Primeiramente, padronize os dados antes de tudo. Isso significa colocar todas as variáveis na mesma escala. Caso contrário, as penalidades seriam aplicadas de forma injusta. Use StandardScaler da biblioteca scikit-learn para isso. Depois, divida os dados em treino e teste. A regularização depende apenas dos dados de treino. Escolha o parâmetro alpha (e l1_ratio) com cuidado. Uma técnica comum é a validação cruzada (cross-validation). Ela testa vários valores e seleciona o melhor. No scikit-learn, existem RidgeCV, LassoCV e ElasticNetCV. Essas classes já implementam a busca automática. Avalie modelos regularizados pelo R² ou MSE. Sempre compare com uma regressão linear sem regularização. Isso mostra se a regularização realmente ajudou. Por fim, interprete os coeficientes com atenção. Eles indicam o impacto de cada variável no resultado. Lembre-se: regularização não resolve todos os problemas. Dados mal coletados ou com poucos exemplos continuam sendo um desafio. Portanto, combine sempre boas práticas de coleta e limpeza. Com esses passos, você estará pronto para usar Ridge, Lasso e Elastic Net.

enunciado: previsão de eficiência energética

Você recebeu um conjunto de dados sobre edifícios. O objetivo é prever a carga de aquecimento (variável alvo). Existem oito características disponíveis:

Área relativa do edifício
Área do telhado
Altura do edifício
Tamanho do vidro
Distribuição do vidro
Orientação (codificada)
Área da superfície do telhado
Área da superfície da parede

Seu trabalho é construir um modelo de regressão linear regularizado. O modelo deve aprender a relação entre as características e a carga de aquecimento. A arquitetura do modelo é simples: uma combinação linear das entradas. A fórmula da regressão linear é: $\hat{y} = w_1 x_1 + w_2 x_2 + … + w_n x_n + b$ Onde $w_i$ são os pesos e $b$ é o intercepto. A regularização Ridge adiciona uma penalidade à soma dos quadrados dos pesos. Para Ridge, a função de custo é: $J(w) = \text{MSE}(w) + \alpha \sum_{i=1}^{n} w_i^2$ Para Lasso, a penalidade usa o valor absoluto dos pesos: $J(w) = \text{MSE}(w) + \alpha \sum_{i=1}^{n} |w_i|$ Elastic Net combina ambas as penalidades: $J(w) = \text{MSE}(w) + \alpha \cdot \text{l1\_ratio} \sum |w_i| + \alpha \cdot (1 – \text{l1\_ratio}) \sum w_i^2$ Hiperparâmetros importantes:

alpha – controla a força da regularização. Quanto maior, mais simples o modelo.
l1_ratio (Elastic Net) – mistura entre Lasso (1) e Ridge (0).
max_iter – número máximo de iterações para convergência.
tol – tolerância para parar o treinamento.

Use validação cruzada para escolher o melhor alpha. Avalie o modelo com o erro quadrático médio (MSE) e o R². Compare os três métodos (Ridge, Lasso, Elastic Net).

Exemplo com Ridge

# Ridge Regression com visualizações
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 RidgeCV, LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.datasets import fetch_openml

# Configurar estilo dos gráficos
sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (12, 5)

# 1. Carregar dados
print("Carregando dados...")
data = fetch_openml(data_id=487, as_frame=True)
X = data.data
y_temp = data.target.to_numpy()
if y_temp.ndim == 2:
    y = y_temp[:, 0]
else:
    y = y_temp

# 2. Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Padronizar
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Treinar Ridge com diferentes alphas para análise
alphas = np.logspace(-3, 3, 50)
ridge_model = RidgeCV(alphas=alphas, store_cv_values=True, scoring='neg_mean_squared_error')
ridge_model.fit(X_train_scaled, y_train)

# 5. Resultados
print(f"Melhor alpha: {ridge_model.alpha_:.4f}")

# 6. Previsões
y_pred_ridge = ridge_model.predict(X_test_scaled)
mse_ridge = mean_squared_error(y_test, y_pred_ridge)
r2_ridge = r2_score(y_test, y_pred_ridge)

print(f"MSE no teste: {mse_ridge:.4f}")
print(f"R² no teste: {r2_ridge:.4f}")

# 7. Comparação com Linear Regression
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)
y_pred_lr = lr.predict(X_test_scaled)
mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")
print(f"Ridge reduziu MSE em {(mse_lr - mse_ridge)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Valores Reais
plt.subplot(1, 2, 1)
plt.scatter(y_test, y_pred_ridge, alpha=0.6, edgecolors='k', linewidth=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Valores Reais')
plt.ylabel('Previsões')
plt.title(f'Ridge: Previsões vs Real\nR² = {r2_ridge:.3f}')

# Gráfico 2: Distribuição dos Erros
plt.subplot(1, 2, 2)
erros = y_test - y_pred_ridge
sns.histplot(erros, bins=30, kde=True)
plt.xlabel('Erro (Real - Previsto)')
plt.ylabel('Frequência')
plt.title(f'Distribuição dos Erros\nMédia = {erros.mean():.3f}, Std = {erros.std():.3f}')
plt.tight_layout()
plt.show()

# Gráfico 3: Comparação de Coeficientes
plt.figure(figsize=(10, 5))
coef_ridge = ridge_model.coef_
coef_lr = lr.coef_
x_pos = np.arange(len(X.columns))
width = 0.35

plt.bar(x_pos - width/2, coef_lr, width, label='Linear Regression', alpha=0.7)
plt.bar(x_pos + width/2, coef_ridge, width, label=f'Ridge (alpha={ridge_model.alpha_:.3f})', alpha=0.7)
plt.xlabel('Características')
plt.ylabel('Coeficiente')
plt.title('Comparação dos Coeficientes')
plt.xticks(x_pos, X.columns, rotation=45, ha='right')
plt.legend()
plt.tight_layout()
plt.show()

# Gráfico 4: Efeito do alpha na validação cruzada
cv_mse = -ridge_model.cv_values_.mean(axis=0)  # Média do MSE por alpha
plt.figure(figsize=(8, 5))
plt.semilogx(alphas, cv_mse, 'b-o', linewidth=2, markersize=6)
plt.axvline(ridge_model.alpha_, color='r', linestyle='--', label=f'Melhor alpha = {ridge_model.alpha_:.4f}')
plt.xlabel('Alpha (escala logarítmica)')
plt.ylabel('MSE médio (validação cruzada)')
plt.title('Escolha do Alpha por Validação Cruzada')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

100

101

102

103

104

105

106

107

108

# Ridge Regression com visualizações

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 RidgeCV, LinearRegression

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.datasets import fetch_openml

# Configurar estilo dos gráficos

sns.set_style("whitegrid")

plt.rcParams['figure.figsize'] = (12, 5)

# 1. Carregar dados

print("Carregando dados...")

data = fetch_openml(data_id=487, as_frame=True)

X = data.data

y_temp = data.target.to_numpy()

if y_temp.ndim == 2:

y = y_temp[:, 0]

else:

y = y_temp

# 2. Dividir dados

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42

)

# 3. Padronizar

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# 4. Treinar Ridge com diferentes alphas para análise

alphas = np.logspace(-3, 3, 50)

ridge_model = RidgeCV(alphas=alphas, store_cv_values=True, scoring='neg_mean_squared_error')

ridge_model.fit(X_train_scaled, y_train)

# 5. Resultados

print(f"Melhor alpha: {ridge_model.alpha_:.4f}")

# 6. Previsões

y_pred_ridge = ridge_model.predict(X_test_scaled)

mse_ridge = mean_squared_error(y_test, y_pred_ridge)

r2_ridge = r2_score(y_test, y_pred_ridge)

print(f"MSE no teste: {mse_ridge:.4f}")

print(f"R² no teste: {r2_ridge:.4f}")

# 7. Comparação com Linear Regression

lr = LinearRegression()

lr.fit(X_train_scaled, y_train)

y_pred_lr = lr.predict(X_test_scaled)

mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")

print(f"Ridge reduziu MSE em {(mse_lr - mse_ridge)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Valores Reais

plt.subplot(1, 2, 1)

plt.scatter(y_test, y_pred_ridge, alpha=0.6, edgecolors='k', linewidth=0.5)

plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)

plt.xlabel('Valores Reais')

plt.ylabel('Previsões')

plt.title(f'Ridge: Previsões vs Real\nR² = {r2_ridge:.3f}')

# Gráfico 2: Distribuição dos Erros

plt.subplot(1, 2, 2)

erros = y_test - y_pred_ridge

sns.histplot(erros, bins=30, kde=True)

plt.xlabel('Erro (Real - Previsto)')

plt.ylabel('Frequência')

plt.title(f'Distribuição dos Erros\nMédia = {erros.mean():.3f}, Std = {erros.std():.3f}')

plt.tight_layout()

plt.show()

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

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

coef_ridge = ridge_model.coef_

coef_lr = lr.coef_

x_pos = np.arange(len(X.columns))

width = 0.35

plt.bar(x_pos - width/2, coef_lr, width, label='Linear Regression', alpha=0.7)

plt.bar(x_pos + width/2, coef_ridge, width, label=f'Ridge (alpha={ridge_model.alpha_:.3f})', alpha=0.7)

plt.xlabel('Características')

plt.ylabel('Coeficiente')

plt.title('Comparação dos Coeficientes')

plt.xticks(x_pos, X.columns, rotation=45, ha='right')

plt.legend()

plt.tight_layout()

plt.show()

# Gráfico 4: Efeito do alpha na validação cruzada

cv_mse = -ridge_model.cv_values_.mean(axis=0) # Média do MSE por alpha

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

plt.semilogx(alphas, cv_mse, 'b-o', linewidth=2, markersize=6)

plt.axvline(ridge_model.alpha_, color='r', linestyle='--', label=f'Melhor alpha = {ridge_model.alpha_:.4f}')

plt.xlabel('Alpha (escala logarítmica)')

plt.ylabel('MSE médio (validação cruzada)')

plt.title('Escolha do Alpha por Validação Cruzada')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()

Exemplo com Lasso

# Lasso Regression com visualizações
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 LassoCV, LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.datasets import fetch_openml

sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (12, 5)

# 1. Carregar dados
print("Carregando dados...")
data = fetch_openml(data_id=487, as_frame=True)
X = data.data
y_temp = data.target.to_numpy()
if y_temp.ndim == 2:
    y = y_temp[:, 0]
else:
    y = y_temp

# 2. Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Padronizar
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Treinar Lasso
alphas = np.logspace(-4, 2, 50)
lasso_model = LassoCV(alphas=alphas, cv=5, random_state=42, max_iter=10000)
lasso_model.fit(X_train_scaled, y_train)

# 5. Resultados
print(f"Melhor alpha: {lasso_model.alpha_:.6f}")
print(f"Coeficientes zerados: {np.sum(lasso_model.coef_ == 0)} de {len(lasso_model.coef_)}")

# 6. Previsões
y_pred_lasso = lasso_model.predict(X_test_scaled)
mse_lasso = mean_squared_error(y_test, y_pred_lasso)
r2_lasso = r2_score(y_test, y_pred_lasso)

print(f"MSE no teste: {mse_lasso:.4f}")
print(f"R² no teste: {r2_lasso:.4f}")

# 7. Comparação
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)
y_pred_lr = lr.predict(X_test_scaled)
mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")
print(f"Lasso reduziu MSE em {(mse_lr - mse_lasso)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Real
plt.subplot(1, 2, 1)
plt.scatter(y_test, y_pred_lasso, alpha=0.6, edgecolors='k', linewidth=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Valores Reais')
plt.ylabel('Previsões Lasso')
plt.title(f'Lasso: Previsões vs Real\nR² = {r2_lasso:.3f}')

# Gráfico 2: Distribuição dos Erros
plt.subplot(1, 2, 2)
erros = y_test - y_pred_lasso
sns.histplot(erros, bins=30, kde=True)
plt.xlabel('Erro (Real - Previsto)')
plt.ylabel('Frequência')
plt.title(f'Distribuição dos Erros\nMédia = {erros.mean():.3f}')
plt.tight_layout()
plt.show()

# Gráfico 3: Coeficientes do Lasso (destacando zerados)
plt.figure(figsize=(10, 5))
cores = ['red' if c == 0 else 'steelblue' for c in lasso_model.coef_]
plt.bar(range(len(lasso_model.coef_)), lasso_model.coef_, color=cores, alpha=0.7)
plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)
plt.xlabel('Características')
plt.ylabel('Coeficiente')
plt.title(f'Coeficientes do Lasso (alpha={lasso_model.alpha_:.5f})\nVermelho = zerados')
plt.xticks(range(len(X.columns)), X.columns, rotation=45, ha='right')
plt.tight_layout()
plt.show()

# Gráfico 4: Caminho de regularização
print("\nCalculando caminho de regularização...")
alphas_path = np.logspace(-4, 2, 100)
coefs = []
for a in alphas_path:
    from sklearn.linear_model import Lasso
    lasso_temp = Lasso(alpha=a, max_iter=10000)
    lasso_temp.fit(X_train_scaled, y_train)
    coefs.append(lasso_temp.coef_)

coefs = np.array(coefs)
plt.figure(figsize=(10, 5))
for i in range(coefs.shape[1]):
    plt.semilogx(alphas_path, coefs[:, i], label=X.columns[i], linewidth=2)
plt.axvline(lasso_model.alpha_, color='black', linestyle='--', label=f'Alpha escolhido = {lasso_model.alpha_:.5f}')
plt.xlabel('Alpha (log scale)')
plt.ylabel('Coeficientes')
plt.title('Caminho de Regularização do Lasso')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

# Lasso Regression com visualizações

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 LassoCV, LinearRegression

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.datasets import fetch_openml

sns.set_style("whitegrid")

plt.rcParams['figure.figsize'] = (12, 5)

# 1. Carregar dados

print("Carregando dados...")

data = fetch_openml(data_id=487, as_frame=True)

X = data.data

y_temp = data.target.to_numpy()

if y_temp.ndim == 2:

y = y_temp[:, 0]

else:

y = y_temp

# 2. Dividir dados

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42

)

# 3. Padronizar

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# 4. Treinar Lasso

alphas = np.logspace(-4, 2, 50)

lasso_model = LassoCV(alphas=alphas, cv=5, random_state=42, max_iter=10000)

lasso_model.fit(X_train_scaled, y_train)

# 5. Resultados

print(f"Melhor alpha: {lasso_model.alpha_:.6f}")

print(f"Coeficientes zerados: {np.sum(lasso_model.coef_ == 0)} de {len(lasso_model.coef_)}")

# 6. Previsões

y_pred_lasso = lasso_model.predict(X_test_scaled)

mse_lasso = mean_squared_error(y_test, y_pred_lasso)

r2_lasso = r2_score(y_test, y_pred_lasso)

print(f"MSE no teste: {mse_lasso:.4f}")

print(f"R² no teste: {r2_lasso:.4f}")

# 7. Comparação

lr = LinearRegression()

lr.fit(X_train_scaled, y_train)

y_pred_lr = lr.predict(X_test_scaled)

mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")

print(f"Lasso reduziu MSE em {(mse_lr - mse_lasso)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Real

plt.subplot(1, 2, 1)

plt.scatter(y_test, y_pred_lasso, alpha=0.6, edgecolors='k', linewidth=0.5)

plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)

plt.xlabel('Valores Reais')

plt.ylabel('Previsões Lasso')

plt.title(f'Lasso: Previsões vs Real\nR² = {r2_lasso:.3f}')

# Gráfico 2: Distribuição dos Erros

plt.subplot(1, 2, 2)

erros = y_test - y_pred_lasso

sns.histplot(erros, bins=30, kde=True)

plt.xlabel('Erro (Real - Previsto)')

plt.ylabel('Frequência')

plt.title(f'Distribuição dos Erros\nMédia = {erros.mean():.3f}')

plt.tight_layout()

plt.show()

# Gráfico 3: Coeficientes do Lasso (destacando zerados)

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

cores = ['red' if c == 0 else 'steelblue' for c in lasso_model.coef_]

plt.bar(range(len(lasso_model.coef_)), lasso_model.coef_, color=cores, alpha=0.7)

plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)

plt.xlabel('Características')

plt.ylabel('Coeficiente')

plt.title(f'Coeficientes do Lasso (alpha={lasso_model.alpha_:.5f})\nVermelho = zerados')

plt.xticks(range(len(X.columns)), X.columns, rotation=45, ha='right')

plt.tight_layout()

plt.show()

# Gráfico 4: Caminho de regularização

print("\nCalculando caminho de regularização...")

alphas_path = np.logspace(-4, 2, 100)

coefs = []

for a in alphas_path:

from sklearn.linear_model import Lasso

lasso_temp = Lasso(alpha=a, max_iter=10000)

lasso_temp.fit(X_train_scaled, y_train)

coefs.append(lasso_temp.coef_)

coefs = np.array(coefs)

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

for i in range(coefs.shape[1]):

plt.semilogx(alphas_path, coefs[:, i], label=X.columns[i], linewidth=2)

plt.axvline(lasso_model.alpha_, color='black', linestyle='--', label=f'Alpha escolhido = {lasso_model.alpha_:.5f}')

plt.xlabel('Alpha (log scale)')

plt.ylabel('Coeficientes')

plt.title('Caminho de Regularização do Lasso')

plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

Exemplo com Elastic Net

# Elastic Net Regression com visualizações
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 ElasticNetCV, LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.datasets import fetch_openml

sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (14, 6)

# 1. Carregar dados
print("Carregando dados...")
data = fetch_openml(data_id=487, as_frame=True)
X = data.data
y_temp = data.target.to_numpy()
if y_temp.ndim == 2:
    y = y_temp[:, 0]
else:
    y = y_temp

# 2. Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Padronizar
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Treinar Elastic Net
alphas = np.logspace(-4, 2, 30)
l1_ratios = np.linspace(0.1, 0.9, 9)
elastic_model = ElasticNetCV(
    l1_ratio=l1_ratios,
    alphas=alphas,
    cv=5,
    random_state=42,
    max_iter=10000
)
elastic_model.fit(X_train_scaled, y_train)

# 5. Resultados
print(f"Melhor alpha: {elastic_model.alpha_:.6f}")
print(f"Melhor l1_ratio: {elastic_model.l1_ratio_:.3f}")
print(f"Coeficientes zerados: {np.sum(elastic_model.coef_ == 0)} de {len(elastic_model.coef_)}")

# 6. Previsões
y_pred_elastic = elastic_model.predict(X_test_scaled)
mse_elastic = mean_squared_error(y_test, y_pred_elastic)
r2_elastic = r2_score(y_test, y_pred_elastic)

print(f"MSE no teste: {mse_elastic:.4f}")
print(f"R² no teste: {r2_elastic:.4f}")

# 7. Comparação
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)
y_pred_lr = lr.predict(X_test_scaled)
mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")
print(f"Elastic Net reduziu MSE em {(mse_lr - mse_elastic)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Real
plt.subplot(1, 2, 1)
plt.scatter(y_test, y_pred_elastic, alpha=0.6, edgecolors='k', linewidth=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Valores Reais')
plt.ylabel('Previsões Elastic Net')
plt.title(f'Elastic Net: Previsões vs Real\nR² = {r2_elastic:.3f}')

# Gráfico 2: Distribuição dos Erros
plt.subplot(1, 2, 2)
erros = y_test - y_pred_elastic
sns.histplot(erros, bins=30, kde=True)
plt.xlabel('Erro (Real - Previsto)')
plt.ylabel('Frequência')
plt.title(f'Distribuição dos Erros\nStd = {erros.std():.3f}')
plt.tight_layout()
plt.show()

# Gráfico 3: Coeficientes dos três métodos
plt.figure(figsize=(12, 5))
x_pos = np.arange(len(X.columns))
width = 0.25

# Re-treinar Ridge e Lasso para comparação justa
from sklearn.linear_model import Ridge, Lasso
ridge_comp = Ridge(alpha=elastic_model.alpha_)
lasso_comp = Lasso(alpha=elastic_model.alpha_, max_iter=10000)
ridge_comp.fit(X_train_scaled, y_train)
lasso_comp.fit(X_train_scaled, y_train)

plt.bar(x_pos - width, ridge_comp.coef_, width, label='Ridge', alpha=0.7)
plt.bar(x_pos, lasso_comp.coef_, width, label='Lasso', alpha=0.7)
plt.bar(x_pos + width, elastic_model.coef_, width, label=f'Elastic Net (l1_ratio={elastic_model.l1_ratio_:.2f})', alpha=0.7)

plt.xlabel('Características')
plt.ylabel('Coeficiente')
plt.title('Comparação de Coeficientes entre Métodos')
plt.xticks(x_pos, X.columns, rotation=45, ha='right')
plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)
plt.legend()
plt.tight_layout()
plt.show()

# Gráfico 4: Heatmap do desempenho por alpha e l1_ratio
print("\nGerando heatmap da validação cruzada...")
mse_matrix = elastic_model.mse_path_.mean(axis=2)  # média dos folds

plt.figure(figsize=(10, 6))
im = plt.imshow(mse_matrix, aspect='auto', cmap='viridis_r', origin='lower')
plt.colorbar(im, label='MSE médio')
plt.xlabel('Índice de alpha')
plt.ylabel('Índice de l1_ratio')
plt.title('Desempenho da Validação Cruzada - Elastic Net')
yticks = range(len(l1_ratios))
yticklabels = [f'{r:.2f}' for r in l1_ratios]
plt.yticks(yticks, yticklabels)
plt.tight_layout()
plt.show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

# Elastic Net Regression com visualizações

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 ElasticNetCV, LinearRegression

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import mean_squared_error, r2_score

from sklearn.datasets import fetch_openml

sns.set_style("whitegrid")

plt.rcParams['figure.figsize'] = (14, 6)

# 1. Carregar dados

print("Carregando dados...")

data = fetch_openml(data_id=487, as_frame=True)

X = data.data

y_temp = data.target.to_numpy()

if y_temp.ndim == 2:

y = y_temp[:, 0]

else:

y = y_temp

# 2. Dividir dados

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42

)

# 3. Padronizar

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# 4. Treinar Elastic Net

alphas = np.logspace(-4, 2, 30)

l1_ratios = np.linspace(0.1, 0.9, 9)

elastic_model = ElasticNetCV(

l1_ratio=l1_ratios,

alphas=alphas,

cv=5,

random_state=42,

max_iter=10000

)

elastic_model.fit(X_train_scaled, y_train)

# 5. Resultados

print(f"Melhor alpha: {elastic_model.alpha_:.6f}")

print(f"Melhor l1_ratio: {elastic_model.l1_ratio_:.3f}")

print(f"Coeficientes zerados: {np.sum(elastic_model.coef_ == 0)} de {len(elastic_model.coef_)}")

# 6. Previsões

y_pred_elastic = elastic_model.predict(X_test_scaled)

mse_elastic = mean_squared_error(y_test, y_pred_elastic)

r2_elastic = r2_score(y_test, y_pred_elastic)

print(f"MSE no teste: {mse_elastic:.4f}")

print(f"R² no teste: {r2_elastic:.4f}")

# 7. Comparação

lr = LinearRegression()

lr.fit(X_train_scaled, y_train)

y_pred_lr = lr.predict(X_test_scaled)

mse_lr = mean_squared_error(y_test, y_pred_lr)

print(f"\nLinear Regression - MSE: {mse_lr:.4f}")

print(f"Elastic Net reduziu MSE em {(mse_lr - mse_elastic)/mse_lr*100:.2f}%")

# ========== GRÁFICOS ==========

# Gráfico 1: Previsões vs Real

plt.subplot(1, 2, 1)

plt.scatter(y_test, y_pred_elastic, alpha=0.6, edgecolors='k', linewidth=0.5)

plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)

plt.xlabel('Valores Reais')

plt.ylabel('Previsões Elastic Net')

plt.title(f'Elastic Net: Previsões vs Real\nR² = {r2_elastic:.3f}')

# Gráfico 2: Distribuição dos Erros

plt.subplot(1, 2, 2)

erros = y_test - y_pred_elastic

sns.histplot(erros, bins=30, kde=True)

plt.xlabel('Erro (Real - Previsto)')

plt.ylabel('Frequência')

plt.title(f'Distribuição dos Erros\nStd = {erros.std():.3f}')

plt.tight_layout()

plt.show()

# Gráfico 3: Coeficientes dos três métodos

plt.figure(figsize=(12, 5))

x_pos = np.arange(len(X.columns))

width = 0.25

# Re-treinar Ridge e Lasso para comparação justa

from sklearn.linear_model import Ridge, Lasso

ridge_comp = Ridge(alpha=elastic_model.alpha_)

lasso_comp = Lasso(alpha=elastic_model.alpha_, max_iter=10000)

ridge_comp.fit(X_train_scaled, y_train)

lasso_comp.fit(X_train_scaled, y_train)

plt.bar(x_pos - width, ridge_comp.coef_, width, label='Ridge', alpha=0.7)

plt.bar(x_pos, lasso_comp.coef_, width, label='Lasso', alpha=0.7)

plt.bar(x_pos + width, elastic_model.coef_, width, label=f'Elastic Net (l1_ratio={elastic_model.l1_ratio_:.2f})', alpha=0.7)

plt.xlabel('Características')

plt.ylabel('Coeficiente')

plt.title('Comparação de Coeficientes entre Métodos')

plt.xticks(x_pos, X.columns, rotation=45, ha='right')

plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)

plt.legend()

plt.tight_layout()

plt.show()

# Gráfico 4: Heatmap do desempenho por alpha e l1_ratio

print("\nGerando heatmap da validação cruzada...")

mse_matrix = elastic_model.mse_path_.mean(axis=2) # média dos folds

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

im = plt.imshow(mse_matrix, aspect='auto', cmap='viridis_r', origin='lower')

plt.colorbar(im, label='MSE médio')

plt.xlabel('Índice de alpha')

plt.ylabel('Índice de l1_ratio')

plt.title('Desempenho da Validação Cruzada - Elastic Net')

yticks = range(len(l1_ratios))

yticklabels = [f'{r:.2f}' for r in l1_ratios]

plt.yticks(yticks, yticklabels)

plt.tight_layout()

plt.show()

Polinomial

23/05/202623/03/2026 Por antonino

curvas que se ajustam à realidade

Regressão polinomial captura relações não lineares entre variáveis usando termos polinomiais. Em vez de uma linha reta, ela cria curvas que se adaptam a padrões mais complexos. Por exemplo, o crescimento populacional frequentemente segue uma curva exponencial, não linear. A equação inclui termos como x², x³, e assim por diante. Primeiramente, transformamos os dados originais adicionando essas novas características polinomiais. Depois, aplicamos os mesmos princípios da regressão linear nesse espaço expandido. Essa técnica permite modelar fenômenos com aceleração, decaimento ou sazonalidade.

grau do polinômio e complexidade

A escolha do grau do polinômio determina a flexibilidade e capacidade do modelo. Grau 1 produz uma linha reta (regressão linear simples tradicional). Grau 2 cria curvas parabólicas que capturam um ponto de máximo ou mínimo. Grau 3 permite curvas com ponto de inflexão e formas mais complexas. Primeiramente, graus mais altos oferecem maior capacidade de ajuste aos dados. Além disso, eles também aumentam o risco de sobreajuste significativo. O equilíbrio entre viés e variância orienta a escolha do grau ideal. Técnicas de validação cruzada ajudam a encontrar esse ponto de equilíbrio.

sobreajuste: o perigo das curvas exageradas

Sobreajuste ocorre quando o modelo se ajusta excessivamente aos ruídos dos dados de treinamento. Polinômios de alto grau podem criar curvas que passam exatamente por todos os pontos. Por exemplo, grau 10 em 11 pontos cria oscilações extremas sem sentido prático. Primeiramente, o modelo perde capacidade de generalização para novos dados não vistos. Além disso, curvas muito complexas não representam fenômenos reais do mundo. Técnicas de regularização adicionam penalidades para coeficientes muito altos no modelo. A validação cruzada revela quando a complexidade adicional deixa de trazer benefícios.

transformação de características na prática

Implementar regressão polinomial requer criar novas características a partir das variáveis originais. Primeiramente, elevamos a variável x às potências desejadas: x², x³, até o grau escolhido. Por exemplo, para grau 3 com variável x, criamos x, x² e x³. Além disso, podemos incluir termos de interação entre diferentes variáveis originais. O algoritmo de regressão linear trata esses novos termos como características independentes. Essa abordagem mantém a simplicidade computacional da regressão linear tradicional. A preparação adequada dos dados é essencial para o sucesso do modelo.

aplicações no mundo real

Regressão polinomial aparece em diversas aplicações onde relações não lineares são evidentes. Primeiramente, previsão de temperatura ao longo do dia segue padrões parabólicos característicos. Além disso, física de projéteis modela trajetórias com equações quadráticas precisas. Na economia, modelos de custo marginal frequentemente apresentam curvas em forma de U. Empresas de energia preveem consumo com padrões sazonais usando termos polinomiais. Na biologia, crescimento de populações segue curvas sigmoides que polinômios aproximam. Para iniciantes, regressão polinomial demonstra como curvas capturam padrões que retas não alcançam. É uma ferramenta poderosa para modelar a complexidade natural dos fenômenos.

Enunciado do Problema

Uma empresa de consultoria deseja criar um modelo preditivo para estimar o salário de funcionários com base nos anos de experiência profissional. Após analisar dados históricos, observou-se que a relação entre experiência e salário não é linear – profissionais mais experientes tendem a ter um crescimento salarial acelerado devido a promoções e especializações. Objetivo: Desenvolver um modelo de Regressão Polinomial que capture essa relação não-linear e faça previsões precisas de salário para diferentes níveis de experiência. Dados disponíveis: 100 registros de funcionários contendo anos de experiência (0-15 anos) e salário correspondente (com pequenas variações naturais).

# ============================================
# REGRESSÃO POLINOMIAL - Exemplo Clássico
# Previsão de Salário com base nos Anos de Experiência
# (Considerando crescimento não-linear)
# ============================================

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# Configurar estilo dos gráficos
plt.style.use('seaborn-v0_8-darkgrid')
plt.rcParams['figure.figsize'] = (12, 6)

# ============================================
# 1. CRIAR CONJUNTO DE DADOS SINTÉTICO
# ============================================
np.random.seed(42)

# Anos de experiência (0 a 15 anos)
X = np.linspace(0, 15, 100).reshape(-1, 1)

# Salário com crescimento não-linear (polinomial)
# Fórmula: Salário = 2000 + 500*exp + 50*exp² + ruído
y_real = 2000 + 500 * X.ravel() + 50 * X.ravel()**2
y = y_real + np.random.normal(0, 500, X.shape[0])

# Criar DataFrame para visualização
df = pd.DataFrame({'Anos_Experiencia': X.ravel(), 'Salario': y})
print("=" * 60)
print("BASE DE DADOS GERADA")
print("=" * 60)
print(df.head(10))
print(f"\nTotal de registros: {len(df)}")
print(f"Salário médio: R$ {df['Salario'].mean():.2f}")
print(f"Salário mínimo: R$ {df['Salario'].min():.2f}")
print(f"Salário máximo: R$ {df['Salario'].max():.2f}")

# ============================================
# 2. DIVIDIR DADOS 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(f"\nDados de Treino: {len(X_train)} amostras")
print(f"Dados de Teste: {len(X_test)} amostras")

# ============================================
# 3. APLICAR REGRESSÃO POLINOMIAL (GRAU 2)
# ============================================
# Criar características polinomiais
poly_features = PolynomialFeatures(degree=2, include_bias=False)
X_train_poly = poly_features.fit_transform(X_train)
X_test_poly = poly_features.transform(X_test)

# Treinar modelo de regressão linear nos dados polinomiais
modelo_poly = LinearRegression()
modelo_poly.fit(X_train_poly, y_train)

# Fazer previsões
y_train_pred = modelo_poly.predict(X_train_poly)
y_test_pred = modelo_poly.predict(X_test_poly)

# ============================================
# 4. COMPARAR COM REGRESSÃO LINEAR SIMPLES
# ============================================
modelo_linear = LinearRegression()
modelo_linear.fit(X_train, y_train)
y_test_pred_linear = modelo_linear.predict(X_test)

# ============================================
# 5. AVALIAR MODELOS
# ============================================
def avaliar_modelo(y_true, y_pred, nome_modelo):
    mse = mean_squared_error(y_true, y_pred)
    rmse = np.sqrt(mse)
    r2 = r2_score(y_true, y_pred)
    
    print(f"\n{nome_modelo}:")
    print(f"  MSE: {mse:.2f}")
    print(f"  RMSE: {rmse:.2f}")
    print(f"  R² Score: {r2:.4f}")
    return {'MSE': mse, 'RMSE': rmse, 'R2': r2}

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

metricas_poly = avaliar_modelo(y_test, y_test_pred, "REGRESSÃO POLINOMIAL (Grau 2)")
metricas_linear = avaliar_modelo(y_test, y_test_pred_linear, "REGRESSÃO LINEAR SIMPLES")

# ============================================
# 6. EXTRAIR COEFICIENTES DA EQUAÇÃO
# ============================================
print("\n" + "=" * 60)
print("EQUAÇÃO DO MODELO POLINOMIAL")
print("=" * 60)
print(f"Intercept (β₀): {modelo_poly.intercept_:.2f}")
print(f"Coeficiente β₁ (Experiência): {modelo_poly.coef_[0]:.2f}")
print(f"Coeficiente β₂ (Experiência²): {modelo_poly.coef_[1]:.2f}")
print(f"\nEquação: Salário = {modelo_poly.intercept_:.2f} + {modelo_poly.coef_[0]:.2f}*X + {modelo_poly.coef_[1]:.2f}*X²")

# ============================================
# 7. VISUALIZAR RESULTADOS
# ============================================
fig, axes = plt.subplots(1, 2, figsize=(15, 6))

# Gráfico 1: Comparação dos Modelos
X_sorted = np.sort(X, axis=0)
X_sorted_poly = poly_features.transform(X_sorted)
y_pred_completo = modelo_poly.predict(X_sorted_poly)
y_pred_linear_completo = modelo_linear.predict(X_sorted)

axes[0].scatter(X, y, alpha=0.5, label='Dados Reais', color='blue')
axes[0].plot(X_sorted, y_pred_completo, 
            label='Regressão Polinomial (Grau 2)', 
            color='red', linewidth=2)
axes[0].plot(X_sorted, y_pred_linear_completo, 
            label='Regressão Linear Simples', 
            color='green', linewidth=2, linestyle='--')
axes[0].set_xlabel('Anos de Experiência', fontsize=12)
axes[0].set_ylabel('Salário (R$)', fontsize=12)
axes[0].set_title('Comparação: Polinomial vs Linear', fontsize=14)
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# Gráfico 2: Previsões vs Valores Reais
axes[1].scatter(y_test, y_test_pred, alpha=0.6, color='red', label='Previsões')
axes[1].plot([y_test.min(), y_test.max()], 
            [y_test.min(), y_test.max()], 
            'k--', lw=2, label='Ideal')
axes[1].set_xlabel('Valores Reais (R$)', fontsize=12)
axes[1].set_ylabel('Previsões (R$)', fontsize=12)
axes[1].set_title(f'Previsões vs Real - R² = {metricas_poly["R2"]:.4f}', fontsize=14)
axes[1].legend()
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# ============================================
# 8. TESTAR COM DIFERENTES GRAUS POLINOMIAIS
# ============================================
print("\n" + "=" * 60)
print("COMPARAÇÃO COM DIFERENTES GRAUS POLINOMIAIS")
print("=" * 60)

graus = [1, 2, 3, 4]
r2_scores = []
mse_scores = []

for grau in graus:
    poly = PolynomialFeatures(degree=grau, include_bias=False)
    X_poly = poly.fit_transform(X_train)
    X_test_poly = poly.transform(X_test)
    
    modelo = LinearRegression()
    modelo.fit(X_poly, y_train)
    y_pred = modelo.predict(X_test_poly)
    
    r2 = r2_score(y_test, y_pred)
    mse = mean_squared_error(y_test, y_pred)
    r2_scores.append(r2)
    mse_scores.append(mse)
    
    print(f"Grau {grau}: R² = {r2:.4f} | MSE = {mse:.2f}")

# Gráfico de comparação de graus
fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(graus, r2_scores, marker='o', linewidth=2, markersize=8)
ax.set_xlabel('Grau do Polinômio', fontsize=12)
ax.set_ylabel('R² Score', fontsize=12)
ax.set_title('Performance por Grau Polinomial', fontsize=14)
ax.grid(True, alpha=0.3)
for i, (grau, r2) in enumerate(zip(graus, r2_scores)):
    ax.annotate(f'{r2:.3f}', (grau, r2), textcoords="offset points", xytext=(0,10), ha='center')
plt.tight_layout()
plt.show()

print("\n✅ Modelo treinado com sucesso!")
print("🎯 Melhor grau baseado no R²:", graus[np.argmax(r2_scores)])

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

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

# REGRESSÃO POLINOMIAL - Exemplo Clássico

# Previsão de Salário com base nos Anos de Experiência

# (Considerando crescimento não-linear)

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

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import PolynomialFeatures

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error, r2_score

# Configurar estilo dos gráficos

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

plt.rcParams['figure.figsize'] = (12, 6)

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

# 1. CRIAR CONJUNTO DE DADOS SINTÉTICO

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

np.random.seed(42)

# Anos de experiência (0 a 15 anos)

X = np.linspace(0, 15, 100).reshape(-1, 1)

# Salário com crescimento não-linear (polinomial)

# Fórmula: Salário = 2000 + 500*exp + 50*exp² + ruído

y_real = 2000 + 500 * X.ravel() + 50 * X.ravel()**2

y = y_real + np.random.normal(0, 500, X.shape[0])

# Criar DataFrame para visualização

df = pd.DataFrame({'Anos_Experiencia': X.ravel(), 'Salario': y})

print("=" * 60)

print("BASE DE DADOS GERADA")

print("=" * 60)

print(df.head(10))

print(f"\nTotal de registros: {len(df)}")

print(f"Salário médio: R$ {df['Salario'].mean():.2f}")

print(f"Salário mínimo: R$ {df['Salario'].min():.2f}")

print(f"Salário máximo: R$ {df['Salario'].max():.2f}")

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

# 2. DIVIDIR DADOS 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(f"\nDados de Treino: {len(X_train)} amostras")

print(f"Dados de Teste: {len(X_test)} amostras")

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

# 3. APLICAR REGRESSÃO POLINOMIAL (GRAU 2)

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

# Criar características polinomiais

poly_features = PolynomialFeatures(degree=2, include_bias=False)

X_train_poly = poly_features.fit_transform(X_train)

X_test_poly = poly_features.transform(X_test)

# Treinar modelo de regressão linear nos dados polinomiais

modelo_poly = LinearRegression()

modelo_poly.fit(X_train_poly, y_train)

# Fazer previsões

y_train_pred = modelo_poly.predict(X_train_poly)

y_test_pred = modelo_poly.predict(X_test_poly)

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

# 4. COMPARAR COM REGRESSÃO LINEAR SIMPLES

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

modelo_linear = LinearRegression()

modelo_linear.fit(X_train, y_train)

y_test_pred_linear = modelo_linear.predict(X_test)

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

# 5. AVALIAR MODELOS

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

def avaliar_modelo(y_true, y_pred, nome_modelo):

mse = mean_squared_error(y_true, y_pred)

rmse = np.sqrt(mse)

r2 = r2_score(y_true, y_pred)

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

print(f" MSE: {mse:.2f}")

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

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

return {'MSE': mse, 'RMSE': rmse, 'R2': r2}

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

print("AVALIAÇÃO DOS MODELOS")

print("=" * 60)

metricas_poly = avaliar_modelo(y_test, y_test_pred, "REGRESSÃO POLINOMIAL (Grau 2)")

metricas_linear = avaliar_modelo(y_test, y_test_pred_linear, "REGRESSÃO LINEAR SIMPLES")

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

# 6. EXTRAIR COEFICIENTES DA EQUAÇÃO

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

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

print("EQUAÇÃO DO MODELO POLINOMIAL")

print("=" * 60)

print(f"Intercept (β₀): {modelo_poly.intercept_:.2f}")

print(f"Coeficiente β₁ (Experiência): {modelo_poly.coef_[0]:.2f}")

print(f"Coeficiente β₂ (Experiência²): {modelo_poly.coef_[1]:.2f}")

print(f"\nEquação: Salário = {modelo_poly.intercept_:.2f} + {modelo_poly.coef_[0]:.2f}*X + {modelo_poly.coef_[1]:.2f}*X²")

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

# 7. VISUALIZAR RESULTADOS

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

fig, axes = plt.subplots(1, 2, figsize=(15, 6))

# Gráfico 1: Comparação dos Modelos

X_sorted = np.sort(X, axis=0)

X_sorted_poly = poly_features.transform(X_sorted)

y_pred_completo = modelo_poly.predict(X_sorted_poly)

y_pred_linear_completo = modelo_linear.predict(X_sorted)

axes[0].scatter(X, y, alpha=0.5, label='Dados Reais', color='blue')

axes[0].plot(X_sorted, y_pred_completo,

label='Regressão Polinomial (Grau 2)',

color='red', linewidth=2)

axes[0].plot(X_sorted, y_pred_linear_completo,

label='Regressão Linear Simples',

color='green', linewidth=2, linestyle='--')

axes[0].set_xlabel('Anos de Experiência', fontsize=12)

axes[0].set_ylabel('Salário (R$)', fontsize=12)

axes[0].set_title('Comparação: Polinomial vs Linear', fontsize=14)

axes[0].legend()

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

# Gráfico 2: Previsões vs Valores Reais

axes[1].scatter(y_test, y_test_pred, alpha=0.6, color='red', label='Previsões')

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

[y_test.min(), y_test.max()],

'k--', lw=2, label='Ideal')

axes[1].set_xlabel('Valores Reais (R$)', fontsize=12)

axes[1].set_ylabel('Previsões (R$)', fontsize=12)

axes[1].set_title(f'Previsões vs Real - R² = {metricas_poly["R2"]:.4f}', fontsize=14)

axes[1].legend()

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

plt.tight_layout()

plt.show()

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

# 8. TESTAR COM DIFERENTES GRAUS POLINOMIAIS

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

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

print("COMPARAÇÃO COM DIFERENTES GRAUS POLINOMIAIS")

print("=" * 60)

graus = [1, 2, 3, 4]

r2_scores = []

mse_scores = []

for grau in graus:

poly = PolynomialFeatures(degree=grau, include_bias=False)

X_poly = poly.fit_transform(X_train)

X_test_poly = poly.transform(X_test)

modelo = LinearRegression()

modelo.fit(X_poly, y_train)

y_pred = modelo.predict(X_test_poly)

r2 = r2_score(y_test, y_pred)

mse = mean_squared_error(y_test, y_pred)

r2_scores.append(r2)

mse_scores.append(mse)

print(f"Grau {grau}: R² = {r2:.4f} | MSE = {mse:.2f}")

# Gráfico de comparação de graus

fig, ax = plt.subplots(figsize=(10, 5))

ax.plot(graus, r2_scores, marker='o', linewidth=2, markersize=8)

ax.set_xlabel('Grau do Polinômio', fontsize=12)

ax.set_ylabel('R² Score', fontsize=12)

ax.set_title('Performance por Grau Polinomial', fontsize=14)

ax.grid(True, alpha=0.3)

for i, (grau, r2) in enumerate(zip(graus, r2_scores)):

ax.annotate(f'{r2:.3f}', (grau, r2), textcoords="offset points", xytext=(0,10), ha='center')

plt.tight_layout()

plt.show()

print("\n✅ Modelo treinado com sucesso!")

print("🎯 Melhor grau baseado no R²:", graus[np.argmax(r2_scores)])

Características do Modelo de Regressão Polinomial

Relações Não-Lineares

Captura relações curvas entre variáveis, diferente da regressão linear que assume relação reta.

Transformação de Features

Cria novas características através de potências da variável original (X, X², X³, etc.).

Maior Flexibilidade

Consegue ajustar curvas complexas aos dados, melhorando a precisão em problemas reais.

Risco de Overfitting

Graus muito altos podem memorizar ruídos em vez de aprender o padrão geral.

Arquitetura do Modelo

A Regressão Polinomial tem a seguinte estrutura matemática:

f(x) = β₀ + β₁·x + β₂·x² + β₃·x³ + … + βₙ·xⁿ + ε

Para nosso exemplo (Grau 2):

Salário = β₀ + β₁·(Experiência) + β₂·(Experiência)² + erro

β₀ (Intercept)

Salário base quando experiência = 0 (ponto de partida).

β₁ (Coeficiente Linear)

Efeito linear da experiência no salário.

β₂ (Coeficiente Quadrático)

Captura a aceleração do crescimento salarial (curvatura).

ε (Erro)

Variação aleatória não explicada pelo modelo.

Como funciona internamente:

1. Transforma a variável original X em [X, X², X³, …] 2. Aplica Regressão Linear Múltipla nessas novas features 3. O resultado é uma curva polinomial que se ajusta aos dados

⚙️ Hiperparâmetros do Modelo

Hiperparâmetro	Valor no Exemplo	Descrição	Impacto
degree	2 (testado 1 a 4)	Grau do polinômio (potência máxima)	Determina a complexidade da curva
include_bias	False	Incluir ou não termo de bias (intercept)	Evita colinearidade com o intercepto
interaction_only	False	Apenas interações entre features	Útil para múltiplas variáveis
fit_intercept	True	Calcula o intercepto β₀	Permite deslocamento vertical da curva

Como escolher o grau ideal?

Grau 1 (Linear)

Muito simples, pode subajustar (underfitting) dados com curvatura.

Grau 2-3 (Ideal)

Bom equilíbrio entre viés e variância.

Grau Alto (10+)

Risco alto de overfitting – memoriza ruídos.

📏 Métricas de Avaliação

R² (Coef. Determinação)

Mede quanto da variabilidade dos dados é explicada pelo modelo. Intervalo: 0 a 1 (quanto mais perto de 1, melhor)

MSE (Erro Quadrático Médio)

Média dos quadrados dos erros. Quanto menor, melhor – penaliza erros grandes.

RMSE (Raiz do MSE)

Erro na mesma unidade da variável alvo. Exemplo: RMSE = R$ 500 significa erro médio de R$500.

📈 Resultados Esperados

Ao executar o código, você observará:

✅ O modelo polinomial (grau 2) terá R² superior à regressão linear simples
✅ A curva se ajustará melhor aos dados, capturando o crescimento acelerado
✅ Gráficos mostrando visualmente a diferença entre os modelos
✅ Comparação de diferentes graus para escolher o melhor

Interpretação dos Coeficientes (exemplo):

Salário = 2000 + 500·X + 50·X² → Um funcionário com 5 anos de experiência: 2000 + 2500 + 1250 = R$ 5.750 → Um funcionário com 10 anos: 2000 + 5000 + 5000 = R$ 12.000

O que é regressão linear e por que regularizar?

Ridge: encolhendo coeficientes sem zerar

Lasso: escolhendo variáveis importantes

Elastic Net: o melhor dos dois mundos

Como aplicar esses métodos na prática

enunciado: previsão de eficiência energética

Exemplo com Ridge

Exemplo com Lasso

Exemplo com Elastic Net

curvas que se ajustam à realidade

grau do polinômio e complexidade

sobreajuste: o perigo das curvas exageradas

transformação de características na prática

aplicações no mundo real

Enunciado do Problema

Características do Modelo de Regressão Polinomial

Relações Não-Lineares

Transformação de Features

Maior Flexibilidade

Risco de Overfitting

Arquitetura do Modelo

Para nosso exemplo (Grau 2):

β₀ (Intercept)

β₁ (Coeficiente Linear)

β₂ (Coeficiente Quadrático)

ε (Erro)

Como funciona internamente:

⚙️ Hiperparâmetros do Modelo

Como escolher o grau ideal?

Grau 1 (Linear)

Grau 2-3 (Ideal)

Grau Alto (10+)

📏 Métricas de Avaliação

R² (Coef. Determinação)

MSE (Erro Quadrático Médio)

RMSE (Raiz do MSE)

📈 Resultados Esperados

Interpretação dos Coeficientes (exemplo):

Vantagens e Desvantagens

✅ Vantagens

❌ Desvantagens