SVM de Uma Classe para Detecção de Novidades

Introdução

Este laboratório guiará você por um exemplo de uso de SVM de uma classe para detecção de novidades. O SVM de uma classe é um algoritmo não supervisionado que aprende uma função de decisão para detecção de novidades: classificar novos dados como semelhantes ou diferentes do conjunto de treinamento.

Dicas da Máquina Virtual

Após o início da VM, 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 de 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 prontamente o problema para você.

Import necessary libraries and generate data

The first step is to import the necessary libraries and generate data. We will use numpy and matplotlib for generating and visualizing data, and scikit-learn for building the one-class SVM model.

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

## Generate train data
X = 0.3 * np.random.randn(100, 2)
X_train = np.r_[X + 2, X - 2]

## Generate some regular novel observations
X = 0.3 * np.random.randn(20, 2)
X_test = np.r_[X + 2, X - 2]

## Generate some abnormal novel observations
X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))

Importação de bibliotecas e geração de dados

O primeiro passo é importar as bibliotecas necessárias e gerar os dados. Usaremos o numpy e o matplotlib para gerar e visualizar os dados, e o scikit-learn para construir o modelo SVM de uma classe.

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

## Gerar dados de treinamento
X = 0.3 * np.random.randn(100, 2)
X_train = np.r_[X + 2, X - 2]

## Gerar algumas observações regulares e novas
X = 0.3 * np.random.randn(20, 2)
X_test = np.r_[X + 2, X - 2]

## Gerar algumas observações novas e anormais
X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))

Ajustar o modelo SVM de uma classe

Em seguida, ajustaremos o modelo SVM de uma classe aos dados gerados.

## Ajustar o modelo
clf = svm.OneClassSVM(nu=0.1, kernel="rbf", gamma=0.1)
clf.fit(X_train)

## Prever as etiquetas para os dados de treinamento, observações regulares e novas, e observações novas anormais
y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)

Calcular o número de erros

Calcularemos o número de erros cometidos pelo modelo nos dados de treino, observações regulares e novas, e observações novas anormais.

## Contar o número de erros
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

Visualizar os resultados

Finalmente, visualizaremos os resultados do modelo SVM de uma classe. Iremos plotar a fronteira de decisão, os dados de treino, as observações regulares e novas, e as observações novas anormais.

## Visualizar os resultados
xx, yy = np.meshgrid(np.linspace(-5, 5, 500), np.linspace(-5, 5, 500))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.title("Detecção de Novidades")
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 = 40
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((-5, 5))
plt.ylim((-5, 5))
plt.legend(
    [a.collections[0], b1, b2, c],
    [
        "fronteira aprendida",
        "observações de treino",
        "observações regulares novas",
        "observações anormais novas",
    ],
    loc="upper left",
    prop=matplotlib.font_manager.FontProperties(size=11),
)
plt.xlabel(
    "erro treino: %d/200 ; erros novos regulares: %d/40 ; erros novos anormais: %d/40"
    % (n_error_train, n_error_test, n_error_outliers)
)
plt.show()

Resumo

Neste laboratório, aprendemos como utilizar o SVM de uma classe para detecção de novidades. Gerámos dados, ajustámos o modelo SVM de uma classe, calculamos o número de erros e visualizamos os resultados. O SVM de uma classe é um algoritmo útil para detetar anomalias nos dados e pode ser aplicado a uma vasta gama de aplicações.