Desmitificando Elliptic Envelope: Una exploración de la detección de anomalías con estimación de covarianza elíptica

Entre los algoritmos de Machine Learning para la detección de anomalías Elliptic Envelope destaca por su capacidad para modelar la distribución de los datos utilizando una elipse en el espacio de características. Un enfoque efectivo para identificar anomalías en conjuntos de datos multivariados donde la mayoría de los datos se distribuyen de manera normal. Lo que lo convierte en un algoritmo popular para la detección de anomalías. En esta entrada se analizarían los fundamentos de Elliptic Envelope y se verá cómo usar la implementación de la biblioteca Scikit-learn de Python.

Fundamentos de Elliptic Envelope

Elliptic Envelope es un algoritmo de detección de anomalías basado en el modelado de los datos como una elipse en un espacio de características de alta dimensión. La idea detrás de este es que los datos normales tienden a formar una distribución aproximadamente elíptica, mientras que las anomalías pueden estar más dispersas. Elliptic Envelope estima los parámetros de una elipse que mejor se ajusta a los datos normales y luego identifica los puntos que caen fuera de esta elipse como anomalías.

Funcionamiento de Elliptic Envelope

El funcionamiento de Elliptic Envelope se puede resumir en los siguientes pasos:

1. Modelado de los datos como una elipse: Elliptic Envelope ajusta una elipse a los datos normales utilizando técnicas de estimación de covarianza. La elipse se define mediante su centro, sus ejes principales y su matriz de covarianza.
2. Identificación de anomalías: Una vez que se ha ajustado la elipse, Elliptic Envelope identifica los puntos que caen fuera de la elipse como anomalías. Esto se hace calculando la distancia de Mahalanobis de cada punto de datos al centro de la elipse y comparándola con un umbral predefinido.

Parámetros de Elliptic Envelope en Scikit-learn

La biblioteca Scikit-learn cuenta con una implementación de Elliptic Envelope que, como es habitual, es eficiente y fácil de usar. Aun así, es importante conocer los hiperparámetros que pueden influir en el rendimiento de los modelos, estos son:

• Contaminación (contamination): Indica la proporción esperada de anomalías en el conjunto de datos. Un valor más bajo resultará en una mayor sensibilidad a las anomalías, pero también puede aumentar el riesgo de falsos positivos.
• Estimador de Covarianza (support_fraction): Especifica la fracción de puntos de datos que se utilizarán para estimar la matriz de covarianza. Un valor más bajo puede reducir la sensibilidad a los valores atípicos, pero también puede hacer que la estimación sea menos precisa.

Creación de modelos basados en Elliptic Envelope con Scikit-learn

La clase de Scikit-learn con la que se implementa Elliptic Envelope es EllipticEnvelope. Como es habitual para implementar un modelo solamente se debe importar la clase, crear una instancia seleccionado los hiperparámetros y entrenar esta instancia con un conjunto de datos. Lo que se muestra en el siguiente ejemplo.

from sklearn.covariance import EllipticEnvelope

# Crear el modelo Elliptic Envelope
elliptic_envelope = EllipticEnvelope(contamination=0.1)

# Entrenar el modelo
elliptic_envelope.fit(data)

# Predicción de anomalías
predictions = elliptic_envelope.predict(data)

En este ejemplo, data representa un conjunto de datos. Una vez entrenado el modelo con el método fit() se puede obtener una predicción mediante el uso del método predict(). Al igual que en One-Class SVM este método devuelve el valor -1 para anomalías y 1 para los datos normales.

Caso práctico con Elliptic Envelope en Scikit-learn

Ahora se puede crear un conjunto de datos sintéticos para analizar cómo funciona la implementación de Scikit-learn. Para ello se puede usar el mismo ejemplo usado en One-Class SVM. Cuando un conjunto de datos sintético con la make_moons() y agregando anomalías a este con la función random.uniform() de NumPy.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons

# Generar datos sintéticos con make_moons
X, _ = make_moons(n_samples=1000, noise=0.1, random_state=42)

# Introducir algunas anomalías
anomalies = np.random.uniform(low=-1.5, high=2.5, size=(100, 2))

# Combinar datos normales y anomalías
data = np.vstack([X, anomalies])

# Visualizar los datos con las anomalías en un color diferente
plt.figure(figsize=(8, 6))
plt.scatter(data[:, 0], data[:, 1], alpha=0.7, c='blue', label='Datos')
plt.scatter(anomalies[:, 0], anomalies[:, 1], color='red', label='Anomalías')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Datos Generados con Anomalías')
plt.legend()
plt.show()

Tras la obtención del conjunto de datos, se pueden usar los pasos descritos anteriormente para entrenar un modelo e identificar los datos normales y anómalos. Lo que, en este caso, se hace mediante el método predict(). Una vez obtenidas las predicciones se puede crear una gráfica en la que las anomalías se marcan con círculos rojos.

from sklearn.covariance import EllipticEnvelope

# Crear el modelo Elliptic Envelope
elliptic_envelope = EllipticEnvelope(contamination=0.1)

# Entrenar el modelo
elliptic_envelope.fit(data)

# Predicción de anomalías
predictions = elliptic_envelope.predict(data)

# Visualizar los resultados con círculos sobre las anomalías
plt.figure(figsize=(8, 6))
plt.scatter(data[:, 0], data[:, 1], alpha=0.7, c='blue', label='Datos')
plt.scatter(data[predictions == -1][:, 0], data[predictions == -1][:, 1],
            facecolors='none', edgecolors='r', s=100, label='Anomalías Detectadas')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Detención de Anomalías con Elliptic Envelope')
plt.legend()
plt.show()

Lo que se puede ver en este ejemplo es que, con la parametrización usada, el modelo en general detecta bien las anomalías que se alejan de las lunas. Aunque se observan bastante falsos positivos en los bordes. Lo que indica que posiblemente, para este conjunto de datos no sea la mejor opción. Aunque los resultados no son del todo malos.

Uso en datos con distribución normal

También se puede analizar cómo funciona Elliptic Envelope con los datos generados cuando se estudió Isolation Forest. En este caso se generaron un conjunto de datos con una distribución normal para posteriormente agregar datos que representan las anomalías. Para lo que se usó el siguiente código.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Generar datos sintéticos de transacciones financieras
np.random.seed(42)

# Generar transacciones normales
normal_transactions = np.random.normal(loc=100, scale=20, size=(1000, 2))

# Generar transacciones fraudulentas (anomalías)
fraudulent_transactions = np.random.uniform(low=300, high=500, size=(50, 2))

# Combinar transacciones normales y fraudulentas
transactions = np.vstack((normal_transactions, fraudulent_transactions))

# Etiquetar transacciones (0 para normal, 1 para anomalía)
labels = np.zeros(len(transactions), dtype=int)
labels[-50:] = 1

# Crear un DataFrame de pandas
data = pd.DataFrame(transactions, columns=['Monto', 'Tiempo'])

# Visualizar los datos
plt.scatter(data['Monto'], data['Tiempo'], c=labels, cmap='coolwarm', alpha=0.7)
plt.xlabel('Monto')
plt.ylabel('Tiempo')
plt.title('Transacciones Financieras')
plt.show()

Ahora, si se entrena un modelo sobre este conjunto de datos, se puede ver que el redimieron de Elliptic Envelope es bastante mejor.

from sklearn.covariance import EllipticEnvelope

# Crear el modelo Elliptic Envelope
elliptic_envelope = EllipticEnvelope(contamination=0.05)

# Entrenar el modelo
elliptic_envelope.fit(transactions)

# Predicción de anomalías
predictions = elliptic_envelope.predict(transactions)

# Visualizar los resultados con círculos sobre las anomalías
plt.figure(figsize=(8, 6))
plt.scatter(transactions[:, 0], transactions[:, 1], alpha=0.7, c='blue', label='Datos')
plt.scatter(transactions[predictions == -1][:, 0], transactions[predictions == -1][:, 1],
            facecolors='none', edgecolors='r', s=100, label='Anomalías Detectadas')
plt.xlabel('Monto')
plt.ylabel('Tiempo')
plt.title('Detención de Anomalías en Datos de Transacciones con Elliptic Envelope')
plt.legend()
plt.show()

En esta nueva gráfica solamente hay unos 3 falsos positivos, pero estos se pueden mejorar ajustando la contaminación.

Conclusiones

Elliptic Envelope es un algoritmo popular para la detección de anomalías que cuenta con una implementación en Scikit-learn. Por lo que se puede emplear en los proyectos que lo necesiten con Python. Su capacidad para modelar los datos como una elipse y luego identificar puntos que caen fuera de esta elipse como anomalías lo convierten en una opción para muchas aplicaciones prácticas.

Imagen de Dmitriy en Pixabay