S08L02 – Regressão polinomial em conjunto de dados com múltiplas características

html
Dominando a Regressão Polinomial com Múltiplas Características: Um Guia Abrangente
No domínio do aprendizado de máquina, a análise de regressão serve como uma ferramenta fundamental para prever resultados contínuos. Entre as várias técnicas de regressão, a Regressão Polinomial se destaca por sua capacidade de modelar relações complexas e não lineares. Este guia abrangente aprofunda-se na Regressão Polinomial com múltiplas características, aproveitando insights de transcrições de vídeos, apresentações de PowerPoint e notebooks Jupyter para fornecer uma compreensão completa e implementação prática.
Índice

  Introdução aos Modelos de Regressão
  Regressão Linear vs. Multilinear
  O que é Regressão Polinomial?
  Por que Escolher a Regressão Polinomial?
  
    Etapas de Pré-processamento para Regressão Polinomial
    
      1. Importação de Dados
      2. Tratamento de Dados Faltantes
      3. Seleção e Codificação de Características
      4. Escalonamento de Características
    
  
  Construindo um Modelo de Regressão Polinomial
  Escolhendo o Grau Adequado: Equilibrando Viés e Variância
  
    Implementação Prática em Python
    
      Guia Passo a Passo Usando Jupyter Notebook
    
  
  Avaliando o Modelo
  Evitando Overfitting na Regressão Polinomial
  Conclusão


Introdução aos Modelos de Regressão
A análise de regressão é um método estatístico usado para estimar as relações entre variáveis. Ela desempenha um papel fundamental na modelagem preditiva, permitindo-nos prever uma variável dependente com base em uma ou mais variáveis independentes. Os tipos mais comuns são:

  Regressão Linear
  Regressão Multilinear
  Regressão Polinomial

Compreender as nuances de cada um pode melhorar significativamente a precisão e a eficácia dos seus modelos preditivos.
Regressão Linear vs. Multilinear
Antes de mergulhar na Regressão Polinomial, é essencial diferenciar entre Regressão Linear e Regressão Multilinear:

  
    Regressão Linear: Modela a relação entre uma única variável independente e uma variável dependente ajustando uma equação linear.
    Equação:
    \[ Y = B_0 + B_1X_1 \]
  
  
    Regressão Multilinear: Estende a regressão linear para modelar relações entre múltiplas variáveis independentes e uma variável dependente.
    Equação:
    \[ Y = B_0 + B_1X_1 + B_2X_2 + B_3X_3 + \ldots + B_nX_n \]
  

Embora ambas sejam poderosas, elas são limitadas a modelar relações lineares.
O que é Regressão Polinomial?
A Regressão Polinomial é uma extensão da regressão linear e multilinear que modela a relação entre a variável dependente e as variáveis independentes como um polinômio de grau \( n \).
Equação:
\[ Y = B_0 + B_1X + B_2X^2 + B_3X^3 + \ldots + B_nX^n \]
Apesar do nome, a Regressão Polinomial é um tipo de regressão linear porque os coeficientes \( B_i \) são lineares.
Por que Escolher a Regressão Polinomial?
Dados do mundo real frequentemente exibem relações não lineares. A Regressão Polinomial proporciona a flexibilidade para capturar essas complexidades ao introduzir termos polinomiais, permitindo que o modelo ajuste curvaturas nos dados.
Benefícios:

  Captura relações não lineares.
  Fornece um melhor ajuste para tendências de dados complexas.
  Melhora o desempenho do modelo quando modelos lineares são insuficientes.


Etapas de Pré-processamento para Regressão Polinomial
O pré-processamento eficaz estabelece a base para um modelo de regressão robusto. Aqui estão as etapas essenciais:
1. Importação de Dados
Comece importando o conjunto de dados. Para ilustração, usaremos um conjunto de dados de seguros do Kaggle.




		
		
			
			
Java
			
			import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()

data = pd.read_csv('insurance.csv')
			
				
					
				
					1
2
3
4
5
6
7
				
						import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
 
data = pd.read_csv('insurance.csv')
					
				
			
		


2. Tratamento de Dados Faltantes
Certifique-se de que seu conjunto de dados esteja livre de valores faltantes. A Regressão Polinomial não lida intrinsecamente com dados faltantes.




		
		
			
			
Java
			
			data.isnull().sum()
# Handle missing values if any
			
				
					
				
					1
2
				
						data.isnull().sum()
# Handle missing values if any
					
				
			
		


Nota: Em problemas de regressão que preveem valores contínuos, o tratamento de dados desequilibrados não é necessário, pois não há desequilíbrio de categorias.
3. Seleção e Codificação de Características
Identifique as características relevantes e codifique as variáveis categóricas.
Codificação de Rótulo:
Transforma rótulos categóricos em forma numérica.




		
		
			
			
Java
			
			from sklearn import preprocessing
le = preprocessing.LabelEncoder()

X['sex'] = le.fit_transform(X['sex'])
X['smoker'] = le.fit_transform(X['smoker'])
			
				
					
				
					1
2
3
4
5
				
						from sklearn import preprocessing
le = preprocessing.LabelEncoder()
 
X['sex'] = le.fit_transform(X['sex'])
X['smoker'] = le.fit_transform(X['smoker'])
					
				
			
		


Codificação One-Hot:
Converte variáveis categóricas em uma forma que pode ser fornecida aos algoritmos de ML para melhorar o desempenho na previsão.




		
		
			
			
Java
			
			from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), [5])], remainder='passthrough')
X = columnTransformer.fit_transform(X)
			
				
					
				
					1
2
3
4
5
				
						from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
 
columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), [5])], remainder='passthrough')
X = columnTransformer.fit_transform(X)
					
				
			
		


4. Escalonamento de Características
Características polinomiais podem levar a magnitudes grandes, causando problemas computacionais e afetando o desempenho do modelo. O escalonamento garante que as características contribuam igualmente.




		
		
			
			
Java
			
			from sklearn import preprocessing

sc = preprocessing.StandardScaler()
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn import preprocessing
 
sc = preprocessing.StandardScaler()
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
					
				
			
		



Construindo um Modelo de Regressão Polinomial
Uma vez concluído o pré-processamento, construir o modelo envolve as seguintes etapas:

  Divisão do Conjunto de Dados: Divida os dados em conjuntos de treinamento e teste.
  Transformação de Características: Gere características polinomiais.
  Treinamento do Modelo: Ajuste o modelo de regressão nas características transformadas.
  Fazendo Previsões: Faça previsões usando o modelo treinado.
  Avaliando o Desempenho: Avalie a precisão do modelo.


Escolhendo o Grau Adequado: Equilibrando Viés e Variância
O grau do polinômio determina a flexibilidade do modelo:

  Grau Baixo (por exemplo, 2): Pode subajustar, falhando em capturar a complexidade dos dados.
  Grau Alto: Pode overajustar, modelando o ruído em vez do padrão subjacente.

Selecionar o grau apropriado é crucial para equilibrar o viés (erro devido a modelos excessivamente simplistas) e a variância (erro devido a modelos excessivamente complexos).

Implementação Prática em Python
Vamos percorrer uma implementação passo a passo usando um Jupyter Notebook.
Guia Passo a Passo Usando Jupyter Notebook
1. Importação de Bibliotecas e Conjunto de Dados




		
		
			
			
Java
			
			import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.metrics import r2_score
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()

# Importando o dataset
data = pd.read_csv('insurance.csv')
X = data.iloc[:, :-1]
Y = data.iloc[:, -1]
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.metrics import r2_score
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
 
# Importando o dataset
data = pd.read_csv('insurance.csv')
X = data.iloc[:, :-1]
Y = data.iloc[:, -1]
					
				
			
		


2. Codificação de Rótulo




		
		
			
			
Java
			
			from sklearn import preprocessing
le = preprocessing.LabelEncoder()

X['sex'] = le.fit_transform(X['sex'])
X['smoker'] = le.fit_transform(X['smoker'])
			
				
					
				
					1
2
3
4
5
				
						from sklearn import preprocessing
le = preprocessing.LabelEncoder()
 
X['sex'] = le.fit_transform(X['sex'])
X['smoker'] = le.fit_transform(X['smoker'])
					
				
			
		


3. Codificação One-Hot




		
		
			
			
Java
			
			from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), [5])], remainder='passthrough')
X = columnTransformer.fit_transform(X)
			
				
					
				
					1
2
3
4
5
				
						from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
 
columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), [5])], remainder='passthrough')
X = columnTransformer.fit_transform(X)
					
				
			
		


4. Divisão do Conjunto de Dados




		
		
			
			
Java
			
			X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.20, random_state=1)
			
				
					
				
					1
				
						X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.20, random_state=1)
					
				
			
		


5. Escalonamento de Características




		
		
			
			
Java
			
			from sklearn import preprocessing

sc = preprocessing.StandardScaler()
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn import preprocessing
 
sc = preprocessing.StandardScaler()
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
					
				
			
		


6. Construindo o Modelo de Regressão Polinomial




		
		
			
			
Java
			
			from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures

model = LinearRegression()
poly = PolynomialFeatures(degree=2)  # Você pode experimentar diferentes graus

X_train_poly = poly.fit_transform(X_train)
model.fit(X_train_poly, y_train)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
 
model = LinearRegression()
poly = PolynomialFeatures(degree=2)  # Você pode experimentar diferentes graus
 
X_train_poly = poly.fit_transform(X_train)
model.fit(X_train_poly, y_train)
					
				
			
		


7. Fazendo Previsões




		
		
			
			
Java
			
			X_test_poly = poly.fit_transform(X_test)
y_pred = model.predict(X_test_poly)
			
				
					
				
					1
2
				
						X_test_poly = poly.fit_transform(X_test)
y_pred = model.predict(X_test_poly)
					
				
			
		


8. Avaliando o Modelo




		
		
			
			
Java
			
			# Criando um DataFrame de comparação
comparison = pd.DataFrame()
comparison['Actual'] = y_test
comparison['Predicted'] = y_pred

# Exibindo o Score R²
r2 = r2_score(y_test, y_pred)
print(f"R² Score: {r2:.2f}")  # Output: R² Score: 0.86
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Criando um DataFrame de comparação
comparison = pd.DataFrame()
comparison['Actual'] = y_test
comparison['Predicted'] = y_pred
 
# Exibindo o Score R²
r2 = r2_score(y_test, y_pred)
print(f"R² Score: {r2:.2f}")  # Output: R² Score: 0.86
					
				
			
		


Interpretação: Um score R² de 0.86 indica que aproximadamente 86% da variância na variável dependente é previsível a partir das variáveis independentes.

Avaliando o Modelo
Avaliando um modelo de regressão envolve principalmente avaliar quão bem ele prevê a variável alvo. As métricas comuns incluem:

  R² Score: Indica a proporção da variância da variável dependente que é explicada pelas variáveis independentes.
  Erro Quadrático Médio (MSE): Mede a média dos quadrados dos erros.

Em nossa implementação, o score R² melhorou de 0.76 para 0.86 após a introdução de características polinomiais, demonstrando um desempenho aprimorado do modelo.

Evitando Overfitting na Regressão Polinomial
Embora aumentar o grau das características polinomiais possa melhorar o ajuste do modelo, isso também aumenta o risco de overfitting—onde o modelo captura o ruído em vez do padrão subjacente. Para mitigar o overfitting:

  Validação Cruzada: Use técnicas como validação cruzada k-fold para garantir a generalização do modelo.
  Regularização: Implemente métodos de regularização (por exemplo, Ridge, Lasso) para penalizar coeficientes grandes.
  Seleção de Características: Limite o número de características às mais relevantes.

Equilibrar o grau das características polinomiais é essencial para manter um modelo que seja ao mesmo tempo preciso e generalizável.

Conclusão
A Regressão Polinomial com múltiplas características é uma poderosa extensão dos modelos lineares, capaz de capturar relações complexas e não lineares nos dados. Ao pré-processar meticulosamente os dados, selecionar graus polinomiais apropriados e avaliar o desempenho do modelo, é possível aproveitar todo o potencial da Regressão Polinomial.
Seja prevendo custos de seguros, preços de imóveis ou qualquer outro resultado contínuo, dominar a Regressão Polinomial equipa você com uma ferramenta versátil em seu arsenal de aprendizado de máquina.
Principais Pontos:

  A Regressão Polinomial estende os modelos lineares para capturar padrões não lineares.
  O pré-processamento adequado, incluindo codificação e escalonamento, é crucial.
  Escolher o grau certo equilibra a precisão do modelo e evita overfitting.
  Métricas de avaliação como R² fornecem insights sobre o desempenho do modelo.

Adote a Regressão Polinomial para elevar seus esforços de modelagem preditiva e desbloquear insights mais profundos a partir de seus dados.