Máquinas de Vetores de Suporte | Tutoriais de Aprendizado de Máquina

Introdução

Máquinas de Vetores de Suporte (SVMs) são usadas para análise de classificação e regressão. As SVMs encontram a melhor linha ou hiperplano possível que separa os dados em diferentes classes. A linha ou hiperplano que maximiza a distância entre os dois pontos de dados mais próximos de classes diferentes é chamado de margem. Neste laboratório, exploraremos como o parâmetro C afeta a margem em uma SVM linear.

Dicas da Máquina Virtual

Após o término da inicialização da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para você.

Importar Bibliotecas

Começamos importando as bibliotecas necessárias, incluindo numpy, matplotlib e scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm

Gerar Dados

Geramos 40 pontos separáveis usando a função random.randn do numpy. Os primeiros 20 pontos têm uma média de [-2, -2] e os próximos 20 pontos têm uma média de [2, 2]. Em seguida, atribuímos uma etiqueta de classe 0 aos primeiros 20 pontos e uma etiqueta de classe 1 aos próximos 20 pontos.

np.random.seed(0)
X = np.r_[np.random.randn(20, 2) - [2, 2], np.random.randn(20, 2) + [2, 2]]
Y = [0] * 20 + [1] * 20

Ajustar o Modelo

Ajustamos o modelo SVM usando a classe SVC do scikit-learn. Definimos o kernel como linear e o parâmetro de penalidade C como 1 para o caso não regularizado e 0,05 para o caso regularizado. Em seguida, calculamos o hiperplano separador usando os coeficientes e a intersecção do modelo.

for name, penalty in (("unreg", 1), ("reg", 0.05)):
    clf = svm.SVC(kernel="linear", C=penalty)
    clf.fit(X, Y)

    w = clf.coef_[0]
    a = -w[0] / w[1]
    xx = np.linspace(-5, 5)
    yy = a * xx - (clf.intercept_[0]) / w[1]

Calcular Margens

Calculamos as margens para o hiperplano separador. Primeiro, calculamos a distância da margem usando os coeficientes do modelo. Em seguida, calculamos a distância vertical dos vetores de suporte ao hiperplano usando a inclinação do hiperplano. Finalmente, plotamos a linha, os pontos e os vetores mais próximos do plano.

margin = 1 / np.sqrt(np.sum(clf.coef_**2))
yy_down = yy - np.sqrt(1 + a**2) * margin
yy_up = yy + np.sqrt(1 + a**2) * margin

plt.plot(xx, yy, "k-")
plt.plot(xx, yy_down, "k--")
plt.plot(xx, yy_up, "k--")

plt.scatter(
    clf.support_vectors_[:, 0],
    clf.support_vectors_[:, 1],
    s=80,
    facecolors="none",
    zorder=10,
    edgecolors="k",
    cmap=plt.get_cmap("RdBu"),
)
plt.scatter(
    X[:, 0], X[:, 1], c=Y, zorder=10, cmap=plt.get_cmap("RdBu"), edgecolors="k"
)

plt.axis("tight")
x_min = -4.8
x_max = 4.2
y_min = -6
y_max = 6

Plotar Contorno

Plotamos o contorno da função de decisão. Primeiro, criamos uma malha usando os arrays xx e yy. Em seguida, transformamos a malha em um array 2D e aplicamos o método decision_function da classe SVC para obter os valores previstos. Em seguida, plotamos o contorno usando o método contourf.

YY, XX = np.meshgrid(yy, xx)
xy = np.vstack([XX.ravel(), YY.ravel()]).T
Z = clf.decision_function(xy).reshape(XX.shape)

plt.contourf(XX, YY, Z, cmap=plt.get_cmap("RdBu"), alpha=0.5, linestyles=["-"])

plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)

plt.xticks(())
plt.yticks(())

Exibir os Gráficos

Exibimos os gráficos para os casos não regularizados e regularizados.

plt.show()

Resumo

Neste laboratório, exploramos como o parâmetro C afeta a margem em uma SVM linear. Geramos dados, ajustamos o modelo, calculamos as margens e plotamos os resultados. Em seguida, exibimos os gráficos para os casos não regularizados e regularizados.

Explorando Parâmetros de SVM Linear