SingularCode

Menu

Algoritmo SVM

/ Engenharia de Software, Inteligência Artificial / By
Sumário

Algoritmo SVM

O algoritmo SVM, que significa Máquina de Vetores de Suporte (do inglês, Support Vector Machine), é uma técnica poderosa para resolver problemas de classificação e regressão dentro do campo da aprendizagem de máquina e estatística computacional. O SVM é particularmente útil para lidar com conjuntos de dados de alta dimensão e situações onde a precisão na classificação é crucial. Vamos explorar em detalhes o funcionamento, características e aplicações do SVM.

 

Fundamentos do SVM

O objetivo principal do SVM é encontrar o hiperplano ótimo que separa os conjuntos de dados em classes. Em um espaço bidimensional, esse hiperplano pode ser visualizado como uma linha reta, mas em espaços de dimensões maiores, ele assume a forma de um plano ou superfície multidimensional.

 

Vetores de Suporte

Os vetores de suporte são os dados pontos mais próximos do hiperplano de separação. Estes pontos são críticos para a definição do hiperplano, pois são os que têm maior influência na sua localização e orientação. A margem é definida como a distância entre os vetores de suporte e o hiperplano, e o objetivo do SVM é maximizar essa margem para aumentar a robustez do modelo.

 

Tipos de SVM

  • SVM Linear: Utilizado quando os dados podem ser separados linearmente. É mais simples e rápido de treinar.
  • SVM Não Linear: Utilizado para dados que não podem ser separados linearmente. Requer o uso de funções kernel como RBF (Radial Basis Function), polinomial, e sigmoidal para mapear os dados para um espaço onde eles possam ser separados linearmente.

 

Aplicações do SVM

O SVM é amplamente utilizado em uma variedade de campos, incluindo:

  • Reconhecimento de Padrões: Como na identificação de rostos, gestos, e caracteres manuscritos.
  • Classificação de Textos: Para filtrar spam, categorizar notícias, e análise de sentimentos.
  • Bioinformática: Na classificação de proteínas, previsão de genes, e diagnósticos médicos.
  • Detecção de Fraudes: Em sistemas de segurança e monitoramento financeiro.

 

Vantagens

  • Alta Precisão: Particularmente eficaz em espaços de alta dimensão.
  • Eficiência em Espaços de Grande Dimensão: Funciona bem mesmo quando o número de dimensões excede o número de amostras.
  • Versatilidade: A capacidade de usar diferentes funções kernel permite adaptabilidade a vários tipos de dados.

 

Desvantagens

  • Seleção de Kernel e Parâmetros: A escolha do kernel e a configuração dos parâmetros podem ser complexas e requerem experiência.
  • Escalabilidade: Pode ser computacionalmente intensivo e menos eficiente em conjuntos de dados muito grandes.

Dataset Iris:

import pandas as pd
import seaborn as sns

iris = pd.read_csv("iris.csv")
iris

iris.info()

iris['target'].count()

iris['target'].value_counts()

sns.pairplot(iris, hue = "target")

iris.target.unique()
iris

iris['target'] = iris['target'].map({'SETOSA':1,'VERSICOLOR':2,'VIRGINICA':3})
iris

X = iris.iloc[:,0:4].values
X

y = iris.iloc[:,4].values
y

from sklearn import svm
from sklearn.model_selection import train_test_split
X_trein, X_teste, y_trein, y_teste = train_test_split(X, y, test_size=0.30, random_state=0)
print(len(X_trein),len(X_teste))

#Quando C=1, representa um equilíbrio entre maximizar a margem e minimizar o erro de classificação
classificador = svm.SVC(kernel='linear', C=1.0)
classificador.fit(X_trein, y_trein)

#Acurácia
classificador.score(X_teste,y_teste)

previsao = classificador.predict(X_teste)
previsao

y_teste

from sklearn.metrics import confusion_matrix
confusion_matrix(y_teste, previsao)

from sklearn.metrics import classification_report
print(classification_report(y_teste, previsao))

Gráfico Iris:

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler

# Carregar o conjunto de dados Iris
iris = datasets.load_iris()
X = iris.data  # Características
y = iris.target  # Rótulos das classes

# Normalização dos dados
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Redução de dimensionalidade com t-SNE
tsne = TSNE(n_components=2, random_state=42)
X_tsne = tsne.fit_transform(X_scaled)

# Treinamento do classificador SVM no espaço reduzido
model = svm.SVC(kernel='linear', C=1.0)
model.fit(X_tsne, y)

# Criação da grade para os limites de decisão
x_min, x_max = X_tsne[:, 0].min() - 1, X_tsne[:, 0].max() + 1
y_min, y_max = X_tsne[:, 1].min() - 1, X_tsne[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),
                     np.arange(y_min, y_max, 0.1))

# Previsão de classificação para cada ponto na grade
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Plotar os limites de decisão
plt.contourf(xx, yy, Z, alpha=0.4, cmap=plt.cm.RdYlBu)
plt.colorbar()

# Plotar os pontos de dados
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap=plt.cm.RdYlBu, edgecolors='k')

plt.title('t-SNE com SVM: Limites de Decisão para o Conjunto de Dados Iris')
plt.xlabel('t-SNE característica 1')
plt.ylabel('t-SNE característica 2')
plt.show()

Dataset Wine:

import pandas as pd
import seaborn as sns

wine = pd.read_csv("wine.csv")
wine

wine.info()

# Quantos dados de cada Especie
wine['Wine'].count()

wine['Wine'].value_counts()

wine.Wine.unique()

X = wine.iloc[:,1:14].values
X

y = wine.iloc[:,0].values
y

from sklearn import svm
from sklearn.model_selection import train_test_split

X_trein, X_teste, y_trein, y_teste = train_test_split(X, y, test_size=0.30, random_state=0)
print(len(X_trein),len(X_teste))

#Quando C=1, representa um equilíbrio entre maximizar a margem e minimizar o erro de classificação
classificador = svm.SVC(kernel='linear', C=1.0)
classificador.fit(X_trein, y_trein)

#Acurácia
classificador.score(X_teste,y_teste)

previsao = classificador.predict(X_teste)
previsao

y_teste

from sklearn.metrics import confusion_matrix
confusion_matrix(y_teste, previsao)

from sklearn.metrics import classification_report
print(classification_report(y_teste, previsao))

Grafico Wine:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from sklearn import svm
from sklearn.preprocessing import StandardScaler
import pandas as pd
import seaborn as sns

# Carregar o conjunto de dados Wine
wine = pd.read_csv("wine.csv")

# Separar as características e os rótulos
X = wine.iloc[:, 1:14].values  # Características
y = wine.iloc[:, 0].values  # Rótulos das classes

# Normalização dos dados
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Redução de dimensionalidade com t-SNE
tsne = TSNE(n_components=2, random_state=0)
X_tsne = tsne.fit_transform(X_scaled)

# Treinamento do classificador SVM no espaço reduzido
svm_model = svm.SVC(kernel='linear', C=1.0)
svm_model.fit(X_tsne, y)

# Criação da grade para os limites de decisão
x_min, x_max = X_tsne[:, 0].min() - 1, X_tsne[:, 0].max() + 1
y_min, y_max = X_tsne[:, 1].min() - 1, X_tsne[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),
                     np.arange(y_min, y_max, 0.1))

# Previsão de classificação para cada ponto na grade
Z = svm_model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Plotar os limites de decisão
plt.contourf(xx, yy, Z, alpha=0.4, cmap=plt.cm.RdYlBu)
plt.colorbar()

# Plotar os pontos de dados
sns.scatterplot(x=X_tsne[:, 0], y=X_tsne[:, 1], hue=wine['Wine'], palette=['red', 'blue', 'green'], legend='full', s=60)

plt.title('Visualização t-SNE do Conjunto de Dados Wine com Limites de Decisão SVM')
plt.xlabel('t-SNE característica 1')
plt.ylabel('t-SNE característica 2')
plt.show()

Atualizado em: 07/04/2024 por Nelson H. Koshoji

Sumário