S14L02 – SVR em Python

html
Desbloqueando o Poder da Regressão de Vetores de Suporte (SVR) em Python: Um Guia Abrangente

Índice

Introdução
O que é Regressão de Vetores de Suporte (SVR)?
Por que Escolher SVR?
Visão Geral do Conjunto de Dados: Análise de Dados de Seguro
  
    Características do Conjunto de Dados:
  

Pré-processamento de Dados
  
    1. Importando Bibliotecas
    2. Carregando o Conjunto de Dados
    3. Separando Características e Variável Alvo
    4. Codificação de Rótulos
    5. Codificação One-Hot
    6. Dividindo os Dados
  

Construindo e Treinando o Modelo SVR
  
    1. Importando SVR
    2. Inicializando e Treinando o Modelo
  

Fazendo Previsões e Avaliando o Modelo
  
    1. Previsões
    2. Comparando Valores Reais vs. Previstos
    3. Avaliação do Modelo
  

Interpretando os Resultados
  
    Por que o SVR Desempenhou Mal?
  

Melhorando o Desempenho do SVR
  
    1. Escalonamento de Características:
    2. Ajuste de Hiperparâmetros:
    3. Modelos Alternativos:
  

Conclusão
Recursos Adicionais
FAQs


Introdução
No vasto campo de aprendizado de máquina, os modelos de regressão desempenham um papel fundamental na previsão de resultados contínuos. Dentre esses modelos, a Regressão de Vetores de Suporte (SVR) destaca-se como uma ferramenta poderosa, porém muitas vezes subutilizada. Enquanto as Máquinas de Vetores de Suporte (SVMs) são predominantemente favorecidas para tarefas de classificação, o SVR oferece uma abordagem única para resolver problemas de regressão. Este guia abrangente explora as complexidades do SVR, sua implementação em Python e seu desempenho em cenários do mundo real, particularmente utilizando um conjunto de dados de seguros.

O que é Regressão de Vetores de Suporte (SVR)?
A Regressão de Vetores de Suporte é uma extensão do algoritmo de Máquina de Vetores de Suporte (SVM) adaptada para tarefas de regressão. Diferentemente dos modelos de regressão tradicionais que visam minimizar o erro entre valores previstos e reais, o SVR foca na função de perda insensível a epsilon. Essa abordagem permite que o SVR crie uma margem de tolerância (epsilon) dentro da qual os erros são desconsiderados, levando a um modelo mais robusto contra outliers.

Por que Escolher SVR?
Embora o SVR seja uma ferramenta robusta para regressão, é essencial entender seu posicionamento no campo do aprendizado de máquina:


Pontos Fortes:
  
    Eficaz em espaços de alta dimensão.
    Robusto contra overfitting, especialmente em casos com poucos pontos de dados.
    Utiliza funções de kernel para modelar relacionamentos não lineares.
  

Pontos Fracos:
  
    Computacionalmente intensivo, tornando-o menos adequado para grandes conjuntos de dados.
    O ajuste de hiperparâmetros pode ser complexo.
    Frequentemente superado por métodos de ensemble como Random Forests ou Gradient Boosting em tarefas de regressão.
  



Dadas essas características, o SVR é mais adequado para cenários específicos onde seus pontos fortes podem ser plenamente aproveitados.

Visão Geral do Conjunto de Dados: Análise de Dados de Seguro
Para ilustrar a implementação do SVR, utilizaremos o Conjunto de Dados de Seguro do Kaggle. Este conjunto de dados fornece informações sobre as demografias e atributos relacionados à saúde de indivíduos, com o objetivo de prever os encargos de seguro.

Características do Conjunto de Dados:

age: Idade do beneficiário principal.
sex: Gênero do indivíduo.
bmi: Índice de massa corporal.
children: Número de filhos cobertos pelo seguro de saúde.
smoker: Indicador se o indivíduo fuma.
region: Área residencial nos Estados Unidos.
charges: Custos médicos cobrados pelo seguro de saúde.


Pré-processamento de Dados
Um pré-processamento de dados eficaz é fundamental para o sucesso de qualquer modelo de aprendizado de máquina. Aqui está um detalhamento passo a passo das etapas de pré-processamento utilizando as bibliotecas pandas e sklearn do Python.

1. Importando Bibliotecas




		
		
			
			
Java
			
			import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
			
				
					
				
					1
2
3
4
5
				
						import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
					
				
			
		



2. Carregando o Conjunto de Dados




		
		
			
			
Java
			
			# Carregar o conjunto de dados de seguro
data = pd.read_csv('S07_datasets_13720_18513_insurance.csv')
print(data.head())
			
				
					
				
					1
2
3
				
						# Carregar o conjunto de dados de seguro
data = pd.read_csv('S07_datasets_13720_18513_insurance.csv')
print(data.head())
					
				
			
		



Saída de Exemplo:


age
sex
bmi
children
smoker
region
charges


19
female
27.900
0
yes
southwest
16884.92400


18
male
33.770
1
no
southeast
1725.55230


28
male
33.000
3
no
southeast
4449.46200


33
male
22.705
0
no
northwest
21984.47061


32
male
28.880
0
no
northwest
3866.85520



3. Separando Características e Variável Alvo




		
		
			
			
Java
			
			X = data.iloc[:,:-1]  # Características
Y = data.iloc[:,-1]   # Variável alvo (charges)
			
				
					
				
					1
2
				
						X = data.iloc[:,:-1]  # Características
Y = data.iloc[:,-1]   # Variável alvo (charges)
					
				
			
		



4. Codificação de Rótulos
Variáveis categóricas precisam ser convertidas em formatos numéricos. Utilizamos Codificação de Rótulos para categorias binárias como 'sex' e 'smoker'.




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

# Codificar as colunas 'sex' e 'smoker'
X['sex'] = le.fit_transform(X['sex'])
X['smoker'] = le.fit_transform(X['smoker'])
print(X.head())
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn import preprocessing
le = preprocessing.LabelEncoder()
 
# Codificar as colunas 'sex' e 'smoker'
X['sex'] = le.fit_transform(X['sex'])
X['smoker'] = le.fit_transform(X['smoker'])
print(X.head())
					
				
			
		



Saída de Exemplo:
...

age
sex
bmi
children
smoker
region


19
0
27.9
0
1
southwest


18
1
33.77
1
0
southeast


28
1
33.0
3
0
southeast


33
1
22.705
0
0
northwest


32
1
28.88
0
0
northwest




5. Codificação One-Hot
Para variáveis categóricas com mais de duas categorias, a Codificação One-Hot é preferida. Aqui, a coluna 'region' é uma variável categórica desse tipo.




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

# Aplicar Codificação One-Hot na coluna 'region'
columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), [5])], remainder='passthrough')
X = columnTransformer.fit_transform(X)
print(X)
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
 
# Aplicar Codificação One-Hot na coluna 'region'
columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), [5])], remainder='passthrough')
X = columnTransformer.fit_transform(X)
print(X)
					
				
			
		



Saída de Exemplo:




		
		
			
			
Java
			
			[[0.    0.    0.   ... 27.9   0.    1.  ]
 [0.    0.    1.   ... 33.77  1.    0.  ]
 [0.    0.    1.   ... 33.    3.    0.  ]
 ...
 [0.    0.    1.   ... 36.85  0.    0.  ]
 [0.    0.    0.   ... 25.8   0.    0.  ]
 [0.    1.    0.   ... 29.07  0.    1.  ]]
			
				
					
				
					1
2
3
4
5
6
7
				
						[[0.    0.    0.   ... 27.9   0.    1.  ]
 [0.    0.    1.   ... 33.77  1.    0.  ]
 [0.    0.    1.   ... 33.    3.    0.  ]
 ...
 [0.    0.    1.   ... 36.85  0.    0.  ]
 [0.    0.    0.   ... 25.8   0.    0.  ]
 [0.    1.    0.   ... 29.07  0.    1.  ]]
					
				
			
		



6. Dividindo os Dados
Dividimos o conjunto de dados em conjuntos de treinamento e teste para avaliar o desempenho do modelo.




		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

# Dividir os dados: 80% treinamento e 20% teste
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.20, random_state=1)
			
				
					
				
					1
2
3
4
				
						from sklearn.model_selection import train_test_split
 
# Dividir os dados: 80% treinamento e 20% teste
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.20, random_state=1)
					
				
			
		



Construindo e Treinando o Modelo SVR
Com os dados pré-processados, podemos agora construir o modelo SVR utilizando sklearn.

1. Importando SVR




		
		
			
			
Java
			
			from sklearn.svm import SVR
			
				
					
				
					1
				
						from sklearn.svm import SVR
					
				
			
		



2. Inicializando e Treinando o Modelo




		
		
			
			
Java
			
			# Inicializar o modelo SVR com parâmetros padrão
model = SVR()

# Treinar o modelo com os dados de treinamento
model.fit(X_train, y_train)
			
				
					
				
					1
2
3
4
5
				
						# Inicializar o modelo SVR com parâmetros padrão
model = SVR()
 
# Treinar o modelo com os dados de treinamento
model.fit(X_train, y_train)
					
				
			
		



Saída do Modelo:




		
		
			
			
Java
			
			SVR()
			
				
					
				
					1
				
						SVR()
					
				
			
		



Fazendo Previsões e Avaliando o Modelo
Após o treinamento, usamos o modelo para fazer previsões no conjunto de teste e avaliar seu desempenho utilizando a pontuação R².

1. Previsões




		
		
			
			
Java
			
			# Prever com os dados de teste
y_pred = model.predict(X_test)
			
				
					
				
					1
2
				
						# Prever com os dados de teste
y_pred = model.predict(X_test)
					
				
			
		



2. Comparando Valores Reais vs. Previstos




		
		
			
			
Java
			
			# Criar um DataFrame para comparar os encargos reais e previstos
comparison = pd.DataFrame()
comparison['Actual'] = y_test
comparison['Predicted'] = y_pred
print(comparison.head())
			
				
					
				
					1
2
3
4
5
				
						# Criar um DataFrame para comparar os encargos reais e previstos
comparison = pd.DataFrame()
comparison['Actual'] = y_test
comparison['Predicted'] = y_pred
print(comparison.head())
					
				
			
		



Saída de Exemplo:


Actual
Predicted


1646.43
9111.903501


11353.23
9307.009935


8798.59
9277.155786


10381.48
9265.538282


2103.08
9114.774006



3. Avaliação do Modelo
A pontuação R² indica quão bem as previsões do modelo correspondem aos dados reais. Uma pontuação R² próxima de 1 significa um ajuste melhor.




		
		
			
			
Java
			
			from sklearn.metrics import r2_score

# Calcular a pontuação R²
r2 = r2_score(y_test, y_pred)
print(f'R² Score: {r2}')
			
				
					
				
					1
2
3
4
5
				
						from sklearn.metrics import r2_score
 
# Calcular a pontuação R²
r2 = r2_score(y_test, y_pred)
print(f'R² Score: {r2}')
					
				
			
		



Saída:




		
		
			
			
Java
			
			R² Score: -0.1157396589643176
			
				
					
				
					1
				
						R² Score: -0.1157396589643176
					
				
			
		



Interpretando os Resultados
Uma pontuação R² de -0.1157 significa que o modelo SVR tem um desempenho ruim no conjunto de dados fornecido. Na análise de regressão, valores R² negativos indicam que o modelo ajusta os dados pior do que uma linha horizontal (ou seja, pior do que simplesmente prever a média da variável alvo).

Por que o SVR Desempenhou Mal?
Vários fatores podem contribuir para o desempenho pobre do SVR neste cenário:


Hiperparâmetros Padrão: O desempenho do SVR é altamente sensível aos seus hiperparâmetros (por exemplo, tipo de kernel, C, epsilon). Usar configurações padrão pode não capturar efetivamente os padrões subjacentes nos dados.
Tamanho do Conjunto de Dados: O SVR pode ser computacionalmente intensivo, especialmente com conjuntos de dados maiores. O conjunto de dados de seguro, com 1.338 registros, ainda pode apresentar desafios para o SVR generalizar efetivamente.
Escalonamento de Características: O SVR requer que as características de entrada sejam escalonadas adequadamente. A falta de escalonamento pode levar a um desempenho subótimo.
Relacionamentos Não Lineares: Embora o SVR possa lidar com relacionamentos não lineares usando funções de kernel, a escolha do kernel e seus parâmetros influenciam muito o desempenho.


Melhorando o Desempenho do SVR
Para melhorar o desempenho do modelo SVR, considere as seguintes etapas:

1. Escalonamento de Características:




		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

# Inicializar escalonadores
sc_X = StandardScaler()
sc_y = StandardScaler()

# Ajustar e transformar os dados de treinamento
X_train = sc_X.fit_transform(X_train)
y_train = sc_y.fit_transform(y_train.values.reshape(-1, 1)).ravel()

# Transformar os dados de teste
X_test = sc_X.transform(X_test)
y_test = sc_y.transform(y_test.values.reshape(-1, 1)).ravel()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						from sklearn.preprocessing import StandardScaler
 
# Inicializar escalonadores
sc_X = StandardScaler()
sc_y = StandardScaler()
 
# Ajustar e transformar os dados de treinamento
X_train = sc_X.fit_transform(X_train)
y_train = sc_y.fit_transform(y_train.values.reshape(-1, 1)).ravel()
 
# Transformar os dados de teste
X_test = sc_X.transform(X_test)
y_test = sc_y.transform(y_test.values.reshape(-1, 1)).ravel()
					
				
			
		



2. Ajuste de Hiperparâmetros:
Utilize técnicas como Grid Search com Cross-Validation para encontrar os hiperparâmetros ótimos.




		
		
			
			
Java
			
			from sklearn.model_selection import GridSearchCV

# Definir a grade de parâmetros
param_grid = {
    'C': [0.1, 1, 10, 100],
    'epsilon': [0.01, 0.1, 0.2, 0.5],
    'kernel': ['linear', 'rbf', 'poly']
}

# Inicializar Grid Search
grid_search = GridSearchCV(SVR(), param_grid, cv=5, scoring='r2', n_jobs=-1)

# Executar Grid Search
grid_search.fit(X_train, y_train)

# Melhores parâmetros
print(grid_search.best_params_)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						from sklearn.model_selection import GridSearchCV
 
# Definir a grade de parâmetros
param_grid = {
    'C': [0.1, 1, 10, 100],
    'epsilon': [0.01, 0.1, 0.2, 0.5],
    'kernel': ['linear', 'rbf', 'poly']
}
 
# Inicializar Grid Search
grid_search = GridSearchCV(SVR(), param_grid, cv=5, scoring='r2', n_jobs=-1)
 
# Executar Grid Search
grid_search.fit(X_train, y_train)
 
# Melhores parâmetros
print(grid_search.best_params_)
					
				
			
		



3. Modelos Alternativos:
Dadas as limitações observadas, explorar outros modelos de regressão como Random Forests ou XGBoost pode produzir melhores resultados.

Conclusão
A Regressão de Vetores de Suporte é uma ferramenta poderosa no arsenal de aprendizado de máquina, especialmente para cenários que exigem robustez contra outliers e o manuseio de dados de alta dimensão. No entanto, sua eficácia depende de um pré-processamento meticuloso e ajuste de hiperparâmetros. Em aplicações práticas, como demonstrado com o conjunto de dados de seguro, o SVR pode ter um desempenho inferior em comparação com métodos de ensemble como Random Forests ou Gradient Boosting, que frequentemente oferecem maior precisão em tarefas de regressão.

Para os profissionais que desejam aproveitar o SVR, é imperativo:


Escalonar as Características Apropriadamente: Garantindo que todas as características contribuam igualmente para o modelo.
Otimizar os Hiperparâmetros: Utilizando técnicas como Grid Search para ajustar as configurações do modelo.
Avaliar Modelos Alternativos: Às vezes, outros algoritmos podem ser inerentemente mais adequados para a tarefa em questão.


Compreendendo os pontos fortes e as limitações do SVR, os cientistas de dados podem tomar decisões informadas, garantindo a implantação dos modelos de regressão mais eficazes para seus casos de uso específicos.

Recursos Adicionais

Documentação do SVR do Scikit-learn
Compreendendo Máquinas de Vetores de Suporte
Conjunto de Dados de Seguro no Kaggle


FAQs

1. Quando devo usar Regressão de Vetores de Suporte em vez de outros modelos de regressão?
O SVR é particularmente útil ao lidar com conjuntos de dados de alta dimensão e quando a relação entre as características e a variável alvo é não linear. Também é benéfico quando seu conjunto de dados contém outliers, já que o SVR é robusto contra eles.

2. O SVR pode lidar eficientemente com grandes conjuntos de dados?
O SVR pode ser computacionalmente intensivo com grandes conjuntos de dados, levando a tempos de treinamento mais longos. Para conjuntos de dados consideráveis, métodos de ensemble como Random Forests ou Gradient Boosting podem ser mais eficientes e proporcionar melhor desempenho.

3. Como a escolha do kernel afeta o desempenho do SVR?
A função de kernel determina a transformação dos dados para um espaço de dimensão superior, permitindo que o modelo capture relacionamentos não lineares. Kernels comuns incluem linear, polinomial (poly) e função de base radial (rbf). A escolha do kernel e seus parâmetros (como gamma no rbf) influenciam significativamente o desempenho do SVR.

4. Escalonar as características é obrigatório para o SVR?
Sim, o escalonamento de características é crucial para o SVR. Sem o escalonamento, características com magnitudes maiores podem dominar a função objetivo, levando a um desempenho subótimo. O escalonamento garante que todas as características contribuam igualmente para o modelo.

5. Quais são as alternativas ao SVR para tarefas de regressão?
Alternativas populares incluem Regressão Linear, Árvores de Decisão, Random Forests, Máquinas de Gradiente de Boost (por exemplo, XGBoost) e Redes Neurais. Cada uma tem seus pontos fortes e é adequada para diferentes tipos de problemas de regressão.
age	sex	bmi	children	smoker	region	charges
19	female	27.900	0	yes	southwest	16884.92400
18	male	33.770	1	no	southeast	1725.55230
28	male	33.000	3	no	southeast	4449.46200
33	male	22.705	0	no	northwest	21984.47061
32	male	28.880	0	no	northwest	3866.85520
age	sex	bmi	children	smoker	region
19	0	27.9	0	1	southwest
18	1	33.77	1	0	southeast
28	1	33.0	3	0	southeast
33	1	22.705	0	0	northwest
32	1	28.88	0	0	northwest
Actual	Predicted
1646.43	9111.903501
11353.23	9307.009935
8798.59	9277.155786
10381.48	9265.538282
2103.08	9114.774006