Graficar Sgdocsvm vs Ocsvm

Introducción

En este laboratorio, demostraremos cómo utilizar el Descenso de Gradiente Estocástico (SGD, por sus siglas en inglés) para aproximar la solución de un One-Class SVM en el caso de un kernel RBF.

Compararemos los resultados de esta aproximación con los resultados de utilizar un One-Class SVM con un enfoque kernelizado. El propósito de este laboratorio no es mostrar las ventajas de la aproximación en términos de tiempo de cómputo, sino demostrar que se pueden obtener resultados similares utilizando SGD en un conjunto de datos de ejemplo.

Consejos sobre la VM

Una vez que se haya iniciado 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 para este laboratorio: NumPy, Matplotlib y scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import OneClassSVM
from sklearn.linear_model import SGDOneClassSVM
from sklearn.kernel_approximation import Nystroem
from sklearn.pipeline import make_pipeline

Generar datos

Generaremos un conjunto de datos de ejemplo para este laboratorio. Generaremos 500 muestras de entrenamiento y 20 muestras de prueba. También generaremos 20 muestras anómalas.

random_state = 42
rng = np.random.RandomState(random_state)

## Generar datos de entrenamiento
X = 0.3 * rng.randn(500, 2)
X_train = np.r_[X + 2, X - 2]
## Generar algunas observaciones novedosas regulares
X = 0.3 * rng.randn(20, 2)
X_test = np.r_[X + 2, X - 2]
## Generar algunas observaciones novedosas anómalas
X_outliers = rng.uniform(low=-4, high=4, size=(20, 2))

Ajustar el One-Class SVM

Primero ajustaremos un One-Class SVM con un kernel RBF a nuestro conjunto de datos.

## Hiperparámetros del OCSVM
nu = 0.05
gamma = 2.0

## Ajustar el One-Class SVM
clf = OneClassSVM(gamma=gamma, kernel="rbf", nu=nu)
clf.fit(X_train)
y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)
n_error_train = y_pred_train[y_pred_train == -1].size
n_error_test = y_pred_test[y_pred_test == -1].size
n_error_outliers = y_pred_outliers[y_pred_outliers == 1].size

Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

Ajustar el One-Class SVM utilizando SGD

A continuación, ajustaremos un One-Class SVM utilizando SGD. Utilizaremos una aproximación de kernel para aplicar SGD a nuestro conjunto de datos.

## Ajustar el One-Class SVM utilizando una aproximación de kernel y SGD
transform = Nystroem(gamma=gamma, random_state=random_state)
clf_sgd = SGDOneClassSVM(
    nu=nu, shuffle=True, fit_intercept=True, random_state=random_state, tol=1e-4
)
pipe_sgd = make_pipeline(transform, clf_sgd)
pipe_sgd.fit(X_train)
y_pred_train_sgd = pipe_sgd.predict(X_train)
y_pred_test_sgd = pipe_sgd.predict(X_test)
y_pred_outliers_sgd = pipe_sgd.predict(X_outliers)
n_error_train_sgd = y_pred_train_sgd[y_pred_train_sgd == -1].size
n_error_test_sgd = y_pred_test_sgd[y_pred_test_sgd == -1].size
n_error_outliers_sgd = y_pred_outliers_sgd[y_pred_outliers_sgd == 1].size

Z_sgd = pipe_sgd.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z_sgd = Z_sgd.reshape(xx.shape)

Graficar los resultados

Finalmente, graficaremos los resultados de nuestro One-Class SVM y nuestro One-Class SVM utilizando SGD.

## graficar los conjuntos de nivel de la función de decisión
plt.figure(figsize=(9, 6))
plt.title("One Class SVM")
plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), 0, 7), cmap=plt.cm.PuBu)
a = plt.contour(xx, yy, Z, levels=[0], linewidths=2, colors="darkred")
plt.contourf(xx, yy, Z, levels=[0, Z.max()], colors="palevioletred")

s = 20
b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c="white", s=s, edgecolors="k")
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c="blueviolet", s=s, edgecolors="k")
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c="gold", s=s, edgecolors="k")
plt.axis("tight")
plt.xlim((-4.5, 4.5))
plt.ylim((-4.5, 4.5))
plt.legend(
    [a.collections[0], b1, b2, c],
    [
        "frontera aprendida",
        "observaciones de entrenamiento",
        "nuevas observaciones regulares",
        "nuevas observaciones anómalas",
    ],
    loc="upper left",
)
plt.xlabel(
    "error train: %d/%d; errores novel regular: %d/%d; errores novel abnormal: %d/%d"
    % (
        n_error_train,
        X_train.shape[0],
        n_error_test,
        X_test.shape[0],
        n_error_outliers,
        X_outliers.shape[0],
    )
)
plt.show()

plt.figure(figsize=(9, 6))
plt.title("Online One-Class SVM")
plt.contourf(xx, yy, Z_sgd, levels=np.linspace(Z_sgd.min(), 0, 7), cmap=plt.cm.PuBu)
a = plt.contour(xx, yy, Z_sgd, levels=[0], linewidths=2, colors="darkred")
plt.contourf(xx, yy, Z_sgd, levels=[0, Z_sgd.max()], colors="palevioletred")

s = 20
b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c="white", s=s, edgecolors="k")
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c="blueviolet", s=s, edgecolors="k")
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c="gold", s=s, edgecolors="k")
plt.axis("tight")
plt.xlim((-4.5, 4.5))
plt.ylim((-4.5, 4.5))
plt.legend(
    [a.collections[0], b1, b2, c],
    [
        "frontera aprendida",
        "observaciones de entrenamiento",
        "nuevas observaciones regulares",
        "nuevas observaciones anómalas",
    ],
    loc="upper left",
)
plt.xlabel(
    "error train: %d/%d; errores novel regular: %d/%d; errores novel abnormal: %d/%d"
    % (
        n_error_train_sgd,
        X_train.shape[0],
        n_error_test_sgd,
        X_test.shape[0],
        n_error_outliers_sgd,
        X_outliers.shape[0],
    )
)
plt.show()

Resumen

En este laboratorio, demostramos cómo utilizar el Descenso de Gradiente Estocástico (SGD) para aproximar la solución de un One-Class SVM con un kernel RBF. Comparamos los resultados de esta aproximación con los resultados de utilizar un One-Class SVM con un enfoque kernelizado. Generamos un conjunto de datos de ejemplo y graficamos los resultados de nuestros modelos.