Support Vector Machine ou SVM é um dos algoritmos de aprendizado supervisionado mais populares, usado para problemas de classificação e também de regressão. No entanto, principalmente, é usado para problemas de classificação em aprendizado de máquina.
O objetivo do algoritmo SVM é criar a melhor linha ou limite de decisão que possa segregar o espaço n-dimensional em classes para que possamos facilmente colocar o novo ponto de dados na categoria correta no futuro. Este melhor limite de decisão é chamado de hiperplano.
O SVM escolhe os pontos/vetores extremos que auxiliam na criação do hiperplano. Esses casos extremos são chamados de vetores de suporte e, portanto, o algoritmo é denominado Máquina de Vetores de Suporte. Considere o diagrama abaixo no qual existem duas categorias diferentes que são classificadas usando um limite de decisão ou hiperplano:
Exemplo: O SVM pode ser entendido com o exemplo que usamos no classificador KNN. Suponha que vejamos um gato estranho que também possui algumas características de cães, então se quisermos um modelo que possa identificar com precisão se é um gato ou um cachorro, tal modelo pode ser criado usando o algoritmo SVM. Primeiro treinaremos nosso modelo com muitas imagens de cães e gatos para que ele possa aprender sobre as diferentes características de cães e gatos, e depois o testaremos com esta estranha criatura. Assim, à medida que o vetor de suporte cria um limite de decisão entre esses dois dados (gato e cachorro) e escolhe casos extremos (vetores de suporte), ele verá o caso extremo de gato e cachorro. Com base nos vetores de suporte, irá classificá-lo como um gato. Considere o diagrama abaixo:
O algoritmo SVM pode ser usado para Detecção de rosto, classificação de imagens, categorização de texto, etc.
codificação java instrução if else
Tipos de SVM
O SVM pode ser de dois tipos:
Hiperplano e vetores de suporte no algoritmo SVM:
Hiperplano: Pode haver múltiplas linhas/limites de decisão para segregar as classes no espaço n-dimensional, mas precisamos descobrir o melhor limite de decisão que ajude a classificar os pontos de dados. Este melhor limite é conhecido como hiperplano do SVM.
As dimensões do hiperplano dependem dos recursos presentes no conjunto de dados, o que significa que se houver 2 recursos (como mostrado na imagem), então o hiperplano será uma linha reta. E se houver 3 recursos, então o hiperplano será um plano bidimensional.
Sempre criamos um hiperplano que possui margem máxima, o que significa a distância máxima entre os pontos de dados.
Vetores de suporte:
Os pontos de dados ou vetores que estão mais próximos do hiperplano e que afetam a posição do hiperplano são denominados Vetor de Suporte. Uma vez que esses vetores suportam o hiperplano, são chamados de vetor de suporte.
Como funciona o SVM?
SVM linear:
O funcionamento do algoritmo SVM pode ser entendido usando um exemplo. Suponha que temos um conjunto de dados que possui duas tags (verde e azul) e o conjunto de dados possui dois recursos x1 e x2. Queremos um classificador que possa classificar o par (x1, x2) de coordenadas em verde ou azul. Considere a imagem abaixo:
Portanto, como é um espaço 2-D, usando apenas uma linha reta, podemos facilmente separar essas duas classes. Mas pode haver várias linhas que podem separar essas classes. Considere a imagem abaixo:
Conseqüentemente, o algoritmo SVM ajuda a encontrar a melhor linha ou limite de decisão; este melhor limite ou região é chamado de hiperplano . O algoritmo SVM encontra o ponto mais próximo das linhas de ambas as classes. Esses pontos são chamados de vetores de suporte. A distância entre os vetores e o hiperplano é chamada de margem . E o objetivo do SVM é maximizar essa margem. O hiperplano com margem máxima é chamado de hiperplano ideal .
SVM não linear:
Se os dados estiverem organizados linearmente, podemos separá-los usando uma linha reta, mas para dados não lineares, não podemos desenhar uma única linha reta. Considere a imagem abaixo:
Então, para separar esses pontos de dados, precisamos adicionar mais uma dimensão. Para dados lineares, usamos duas dimensões xey, portanto, para dados não lineares, adicionaremos uma terceira dimensão z. Pode ser calculado como:
z=x<sup>2</sup> +y<sup>2</sup>
Ao adicionar a terceira dimensão, o espaço amostral ficará conforme a imagem abaixo:
Agora, o SVM dividirá os conjuntos de dados em classes da seguinte maneira. Considere a imagem abaixo:
Como estamos no espaço 3-d, ele se parece com um plano paralelo ao eixo x. Se o convertermos no espaço 2d com z = 1, então ficará como:
Conseqüentemente, obtemos uma circunferência de raio 1 no caso de dados não lineares.
Implementação Python da máquina de vetores de suporte
Agora implementaremos o algoritmo SVM usando Python. Aqui usaremos o mesmo conjunto de dados dados do usuário , que usamos na regressão logística e na classificação KNN.
Até a etapa de pré-processamento dos dados, o código permanecerá o mesmo. Abaixo está o código:
#Data Pre-processing Step # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
Após executar o código acima, iremos pré-processar os dados. O código fornecerá o conjunto de dados como:
A saída dimensionada para o conjunto de teste será:
Ajustando o classificador SVM ao conjunto de treinamento:
c#
Agora o conjunto de treinamento será ajustado ao classificador SVM. Para criar o classificador SVM, importaremos SVC aula de Sklearn.svm biblioteca. Abaixo está o código para isso:
from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train)
No código acima, usamos kernel='linear' , pois aqui estamos criando SVM para dados linearmente separáveis. No entanto, podemos alterá-lo para dados não lineares. E então ajustamos o classificador ao conjunto de dados de treinamento (x_train, y_train)
Saída:
Out[8]: SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='auto_deprecated', kernel='linear', max_iter=-1, probability=False, random_state=0, shrinking=True, tol=0.001, verbose=False)
O desempenho do modelo pode ser alterado alterando o valor de C (fator de regularização), gama e kernel .
Agora, iremos prever a saída do conjunto de teste. Para isso, criaremos um novo vetor y_pred. Abaixo está o código para isso:
#Predicting the test set result y_pred= classifier.predict(x_test)
Depois de obter o vetor y_pred, podemos comparar o resultado de y_pred e y_teste para verificar a diferença entre o valor real e o valor previsto.
Saída: Abaixo está a saída para a previsão do conjunto de teste:
projeto único
Agora veremos o desempenho do classificador SVM e quantas previsões incorretas existem em comparação com o classificador de regressão logística. Para criar a matriz de confusão, precisamos importar o matriz_confusão função da biblioteca sklearn. Após importar a função, iremos chamá-la usando uma nova variável cm . A função leva dois parâmetros, principalmente y_true (os valores reais) e y_pred (o valor alvo retornado pelo classificador). Abaixo está o código para isso:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Saída:
Como podemos ver na imagem de saída acima, existem 66+24= 90 previsões corretas e 8+2= 10 previsões corretas. Portanto podemos dizer que nosso modelo SVM melhorou em comparação ao modelo de regressão logística.
Agora vamos visualizar o resultado do conjunto de treinamento, abaixo está o código dele:
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red', 'green'))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Saída:
Ao executar o código acima, obteremos a saída como:
Como podemos ver, a saída acima parece semelhante à saída da regressão logística. Na saída, obtivemos a linha reta como hiperplano porque temos usou um kernel linear no classificador . E também discutimos acima que para o espaço 2d, o hiperplano no SVM é uma linha reta.
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Saída:
Ao executar o código acima, obteremos a saída como:
Como podemos ver na imagem de saída acima, o classificador SVM dividiu os usuários em duas regiões (Comprado ou Não adquirido). Os usuários que compraram o SUV estão na região vermelha com os pontos de dispersão vermelhos. E os usuários que não adquiriram o SUV estão na região verde com pontos de dispersão verdes. O hiperplano dividiu as duas classes em variáveis compradas e não compradas.