Arquivo de AM Supervisionado - Página 23 de 25

1 – Supervisionado
1.1 – Regressao
1.1.3 – Polinomial

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

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

Polinomial

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

Linear Multivariada

múltiplas variáveis, previsões melhores

interpretando múltiplos coeficientes

escalonamento de características

multicolinearidade e seleção de variáveis

aplicações práticas no mundo real