Explorando los parámetros del SVM lineal

Introducción

Las Máquinas de Soporte Vectorial (SVMs) se utilizan para el análisis de clasificación y regresión. Las SVMs buscan la mejor línea o hiperplano posible que separa los datos en diferentes clases. La línea o hiperplano que maximiza la distancia entre los dos puntos de datos más cercanos de diferentes clases se llama margen. En este laboratorio, exploraremos cómo el parámetro C afecta el margen en una SVM lineal.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Importar bibliotecas

Comenzamos importando las bibliotecas necesarias, incluyendo numpy, matplotlib y scikit-learn.

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

Generar datos

Generamos 40 puntos separables utilizando la función random.randn de numpy. Los primeros 20 puntos tienen una media de [-2, -2] y los siguientes 20 puntos tienen una media de [2, 2]. Luego asignamos una etiqueta de clase 0 a los primeros 20 puntos y una etiqueta de clase 1 a los siguientes 20 puntos.

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 el modelo

Ajustamos el modelo SVM utilizando la clase SVC de scikit-learn. Establecemos el kernel en lineal y el parámetro de penalización C en 1 para el caso no regularizado y en 0,05 para el caso regularizado. Luego calculamos el hiperplano separador utilizando los coeficientes y el intercepto del 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 márgenes

Calculamos los márgenes para el hiperplano separador. Primero calculamos la distancia del margen utilizando los coeficientes del modelo. Luego calculamos la distancia vertical desde los vectores de soporte hasta el hiperplano utilizando la pendiente del hiperplano. Finalmente, graficamos la línea, los puntos y los vectores más cercanos al 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

Graficar el contorno

Graficamos el contorno de la función de decisión. Primero creamos una malla (meshgrid) utilizando las matrices xx e yy. Luego redimensionamos la malla en una matriz bidimensional y aplicamos el método decision_function de la clase SVC para obtener los valores predichos. Finalmente, graficamos el contorno utilizando el 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(())

Mostrar las gráficas

Mostramos las gráficas para los casos no regularizado y regularizado.

plt.show()

Resumen

En este laboratorio, exploramos cómo el parámetro C afecta el margen en un SVM lineal. Generamos datos, ajustamos el modelo, calculamos los márgenes y graficamos los resultados. Luego mostramos las gráficas para los casos no regularizado y regularizado.