S23L04 – Implementação de SVM usando python

html
Implementação de Máquinas de Vetor de Suporte (SVM) em Python: Um Guia Abrangente

Bem-vindo ao nosso guia aprofundado sobre a implementação de Máquinas de Vetor de Suporte (SVM) usando a biblioteca scikit-learn do Python. Seja você um entusiasta de ciência de dados ou um profissional experiente, este artigo irá guiá-lo através de todo o processo — desde a compreensão dos conceitos fundamentais de SVM até a execução de uma implementação completa usando um Jupyter Notebook. Vamos começar!

Índice

    Introdução às Máquinas de Vetor de Suporte (SVM)
    Configurando o Ambiente
    Exploração e Pré-processamento de Dados
        
            Tratamento de Dados Faltantes
            Codificação de Variáveis Categóricas
            Seleção de Características
        
    
    Divisão do Conjunto de Dados
    Escalonamento de Características
    Construção e Avaliação de Modelos
        
            K-Vizinhos Mais Próximos (KNN)
            Regressão Logística
            Gaussian Naive Bayes
            Máquina de Vetor de Suporte (SVM)
        
    
    Visualizando Regiões de Decisão
    Conclusão
    Referências



1. Introdução às Máquinas de Vetor de Suporte (SVM)

Máquinas de Vetor de Suporte (SVM) são poderosos modelos de aprendizado supervisionado usados para tarefas de classificação e regressão. Elas são particularmente eficazes em espaços de alta dimensão e são versáteis, graças ao uso de diferentes funções de kernel. As SVMs visam encontrar o hiperplano ótimo que melhor separa os pontos de dados de diferentes classes com a margem máxima.

Principais Características das SVM:

    Otimização da Margem: As SVMs maximizam a margem entre as classes para garantir uma melhor generalização.
    Técnica do Kernel: Permite que as SVMs tenham um bom desempenho em classificações não lineares, transformando os dados em dimensões superiores.
    Robustez: Eficazes em casos com uma margem de separação clara e mesmo em espaços de alta dimensão.



2. Configurando o Ambiente

Antes de começarmos, certifique-se de ter as bibliotecas necessárias instaladas. Você pode instalá-las usando pip:





		
		
			
			
Java
			
			pip install pandas numpy scikit-learn seaborn matplotlib mlxtend
			
				
					
				
					1
				
						pip install pandas numpy scikit-learn seaborn matplotlib mlxtend
					
				
			
		



Nota: mlxtend é usado para visualizar regiões de decisão.


3. Exploração e Pré-processamento de Dados

O pré-processamento de dados é uma etapa crucial em qualquer fluxo de trabalho de machine learning. Envolve limpar os dados, tratar valores ausentes, codificar variáveis categóricas e selecionar características relevantes.

3.1 Tratamento de Dados Faltantes

Dados faltantes podem afetar negativamente o desempenho dos modelos de machine learning. Vamos tratar os valores ausentes por:


    Características Numéricas: Imputar valores ausentes com a média.
    Características Categóricas: Imputar valores ausentes com o valor mais frequente.






		
		
			
			
Java
			
			import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer

# Load the dataset
data = pd.read_csv('weatherAUS.csv')

# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Handle numeric missing values
numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_numeric = SimpleImputer(strategy='mean')
X[numeric_cols] = imputer_numeric.fit_transform(X[numeric_cols])

# Handle categorical missing values
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_categorical = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_categorical.fit_transform(X[categorical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
 
# Load the dataset
data = pd.read_csv('weatherAUS.csv')
 
# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# Handle numeric missing values
numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_numeric = SimpleImputer(strategy='mean')
X[numeric_cols] = imputer_numeric.fit_transform(X[numeric_cols])
 
# Handle categorical missing values
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_categorical = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_categorical.fit_transform(X[categorical_cols])
					
				
			
		



3.2 Codificação de Variáveis Categóricas

Modelos de machine learning requerem entradas numéricas. Vamos converter variáveis categóricas usando:


    Label Encoding: Para categorias binárias ou de alta cardinalidade.
    One-Hot Encoding: Para categorias com um número limitado de valores únicos.






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

# Label Encoding function
def label_encode(series):
    le = LabelEncoder()
    return le.fit_transform(series)

# Apply Label Encoding to target variable
y = label_encode(y)

# Identify columns for encoding
def encoding_selection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_cols = [col for col in string_cols if X[col].nunique() &lt;= threshold]
    label_encode_cols = [col for col in string_cols if X[col].nunique() &gt; threshold]
    
    # Label Encode
    for col in label_encode_cols:
        X[col] = label_encode(X[col])
    
    # One-Hot Encode
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), one_hot_cols)], remainder='passthrough')
    X = ct.fit_transform(X)
    return X

X = encoding_selection(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer
 
# Label Encoding function
def label_encode(series):
    le = LabelEncoder()
    return le.fit_transform(series)
 
# Apply Label Encoding to target variable
y = label_encode(y)
 
# Identify columns for encoding
def encoding_selection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_cols = [col for col in string_cols if X[col].nunique() &lt;= threshold]
    label_encode_cols = [col for col in string_cols if X[col].nunique() &gt; threshold]
    
    # Label Encode
    for col in label_encode_cols:
        X[col] = label_encode(X[col])
    
    # One-Hot Encode
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), one_hot_cols)], remainder='passthrough')
    X = ct.fit_transform(X)
    return X
 
X = encoding_selection(X)
					
				
			
		



3.3 Seleção de Características

Selecionar características relevantes pode melhorar o desempenho do modelo e reduzir a complexidade computacional. Vamos usar SelectKBest com a estatística Qui-Quadrado.





		
		
			
			
Java
			
			from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler

# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Select top 2 features
selector = SelectKBest(score_func=chi2, k=2)
X_selected = selector.fit_transform(X_scaled, y)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
 
# Select top 2 features
selector = SelectKBest(score_func=chi2, k=2)
X_selected = selector.fit_transform(X_scaled, y)
					
				
			
		




4. Divisão do Conjunto de Dados

Vamos dividir o conjunto de dados em conjuntos de treinamento e teste para avaliar o desempenho do modelo em dados não vistos.





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1)
			
				
					
				
					1
2
3
				
						from sklearn.model_selection import train_test_split
 
X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1)
					
				
			
		




5. Escalonamento de Características

O escalonamento de características garante que todas as características contribuam igualmente para o desempenho do modelo.





		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

scaler = StandardScaler(with_mean=False)
scaler.fit(X_train)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.preprocessing import StandardScaler
 
scaler = StandardScaler(with_mean=False)
scaler.fit(X_train)
 
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
					
				
			
		




6. Construção e Avaliação de Modelos

Vamos construir quatro modelos diferentes para comparar seu desempenho:


    K-Vizinhos Mais Próximos (KNN)
    Regressão Logística
    Gaussian Naive Bayes
    Máquina de Vetor de Suporte (SVM)


6.1 K-Vizinhos Mais Próximos (KNN)





		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.4f}')
					
				
			
		



Saída:




		
		
			
			
Java
			
			KNN Accuracy: 0.8003
			
				
					
				
					1
				
						KNN Accuracy: 0.8003
					
				
			
		



6.2 Regressão Logística





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
accuracy_lr = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {accuracy_lr:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.linear_model import LogisticRegression
 
log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
accuracy_lr = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {accuracy_lr:.4f}')
					
				
			
		



Saída:




		
		
			
			
Java
			
			Logistic Regression Accuracy: 0.8297
			
				
					
				
					1
				
						Logistic Regression Accuracy: 0.8297
					
				
			
		



6.3 Gaussian Naive Bayes





		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.naive_bayes import GaussianNB
 
gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.4f}')
					
				
			
		



Saída:




		
		
			
			
Java
			
			Gaussian Naive Bayes Accuracy: 0.7960
			
				
					
				
					1
				
						Gaussian Naive Bayes Accuracy: 0.7960
					
				
			
		



6.4 Máquina de Vetor de Suporte (SVM)





		
		
			
			
Java
			
			from sklearn.svm import SVC

svc = SVC()
svc.fit(X_train, y_train)
y_pred_svc = svc.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.svm import SVC
 
svc = SVC()
svc.fit(X_train, y_train)
y_pred_svc = svc.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc:.4f}')
					
				
			
		



Saída:




		
		
			
			
Java
			
			SVM Accuracy: 0.8282
			
				
					
				
					1
				
						SVM Accuracy: 0.8282
					
				
			
		



Resumo das Precisões dos Modelos:

    
        Modelo
        Precisão
    
    
        KNN
        80,03%
    
    
        Regressão Logística
        82,97%
    
    
        Gaussian Naive Bayes
        79,60%
    
    
        SVM
        82,82%
    


Entre os modelos avaliados, Regressão Logística supera ligeiramente a SVM, seguida de perto pela própria SVM.



7. Visualizando Regiões de Decisão

Visualizar as fronteiras de decisão ajuda a entender como diferentes modelos classificam os dados.





		
		
			
			
Java
			
			from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets

# Load Iris dataset for visualization
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target

# Initialize models
knn_vis = KNeighborsClassifier(n_neighbors=3)
log_reg_vis = LogisticRegression(random_state=0, max_iter=200)
gnb_vis = GaussianNB()
svc_vis = SVC()

# Fit models
knn_vis.fit(X_vis, y_vis)
log_reg_vis.fit(X_vis, y_vis)
gnb_vis.fit(X_vis, y_vis)
svc_vis.fit(X_vis, y_vis)

# Visualization function
def visualize_decision_regions(X, y, model, title):
    plot_decision_regions(X, y, clf=model, legend=2)
    plt.title(title)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.show()

# Plot decision regions for each model
visualize_decision_regions(X_vis, y_vis, knn_vis, 'K-Nearest Neighbors Decision Regions')
visualize_decision_regions(X_vis, y_vis, log_reg_vis, 'Logistic Regression Decision Regions')
visualize_decision_regions(X_vis, y_vis, gnb_vis, 'Gaussian Naive Bayes Decision Regions')
visualize_decision_regions(X_vis, y_vis, svc_vis, 'SVM Decision Regions')
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
				
						from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets
 
# Load Iris dataset for visualization
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target
 
# Initialize models
knn_vis = KNeighborsClassifier(n_neighbors=3)
log_reg_vis = LogisticRegression(random_state=0, max_iter=200)
gnb_vis = GaussianNB()
svc_vis = SVC()
 
# Fit models
knn_vis.fit(X_vis, y_vis)
log_reg_vis.fit(X_vis, y_vis)
gnb_vis.fit(X_vis, y_vis)
svc_vis.fit(X_vis, y_vis)
 
# Visualization function
def visualize_decision_regions(X, y, model, title):
    plot_decision_regions(X, y, clf=model, legend=2)
    plt.title(title)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.show()
 
# Plot decision regions for each model
visualize_decision_regions(X_vis, y_vis, knn_vis, 'K-Nearest Neighbors Decision Regions')
visualize_decision_regions(X_vis, y_vis, log_reg_vis, 'Logistic Regression Decision Regions')
visualize_decision_regions(X_vis, y_vis, gnb_vis, 'Gaussian Naive Bayes Decision Regions')
visualize_decision_regions(X_vis, y_vis, svc_vis, 'SVM Decision Regions')
					
				
			
		



Visualizações:

As fronteiras de decisão de cada modelo serão exibidas em gráficos separados, ilustrando como eles classificam diferentes regiões no espaço de características.


8. Conclusão

Neste guia, exploramos a implementação das Máquinas de Vetor de Suporte (SVM) usando a biblioteca scikit-learn do Python. Começando desde o pré-processamento de dados até a construção e avaliação de vários modelos, incluindo a SVM, cobrimos etapas essenciais em um fluxo de trabalho típico de machine learning. Além disso, a visualização de regiões de decisão proporcionou insights mais profundos sobre como diferentes algoritmos desempenham tarefas de classificação.

Principais Pontos:

    Pré-processamento de Dados: Crucial para limpar e preparar os dados para modelagem.
    Seleção e Escalonamento de Características: Melhoram o desempenho e a eficiência do modelo.
    Comparação de Modelos: Avaliar múltiplos algoritmos ajuda na seleção do melhor desempenho para o seu conjunto de dados.
    Visualização: Uma ferramenta poderosa para entender o comportamento do modelo e os processos de tomada de decisão.


Seguindo esta abordagem abrangente, você pode implementar efetivamente a SVM e outros algoritmos de classificação para resolver problemas do mundo real.


9. Referências


    Documentação do Scikit-Learn
    Máquinas de Vetor de Suporte - Wikipedia
    MLxtend: Extensões de Machine Learning




Obrigado por ler! Se você tiver alguma dúvida ou feedback, sinta-se à vontade para deixar um comentário abaixo.
Modelo	Precisão
KNN	80,03%
Regressão Logística	82,97%
Gaussian Naive Bayes	79,60%
SVM	82,82%