Aplicación de AdaBoost para Detección de Anomalías

Odisea Algorítmica: De la Regresión al Aprendizaje Profundo · Descripción Unificada

AdaBoost (Adaptive Boosting) es un algoritmo de ensemble que combina múltiples clasificadores débiles para formar un predictor fuerte. Su capacidad de adaptar los pesos de las muestras lo convierte en una herramienta poderosa para la detección de anomalías, especialmente cuando los eventos anómalos son raros pero críticos (como fraudes financieros, fallos mecánicos o intrusiones en redes). Al enfatizar iterativamente las muestras mal clasificadas —incluidas las atípicas—, el modelo aprende a identificar patrones que se desvían de la norma.

Fundamento conceptual: pesos adaptativos en anomalías

En problemas de detección de anomalías, el desbalance de clases es extremo (por ejemplo, 99.8%的正常 vs 0.2% anomalías). AdaBoost aborda este desbalance mediante un mecanismo de pesos dinámicos:

• Inicialización: todas las muestras (normales y anómalas) comienzan con el mismo peso.
• Iteración: tras cada clasificador débil, se incrementa el peso de las muestras mal clasificadas. Las anomalías, al ser difíciles de clasificar correctamente, reciben progresivamente mayor atención.
• Ensemble: la votación final ponderada da más influencia a los clasificadores que logran identificar las rarezas.

Arquitectura del algoritmo para anomalías

El proceso adaptativo puede resumirse en los siguientes pasos (adaptados para detección de anomalías):

1. Pesos iniciales uniformes: \( w_i^{(1)} = 1/N \) para todas las \( N \) instancias.
2. Entrenar clasificador débil \( h_t(x) \) usando los pesos actuales (por ejemplo, un stump de decisión o una regresión logística ligera).
3. Calcular error ponderado \( \epsilon_t = \sum_{i: h_t(x_i) \ne y_i} w_i^{(t)} \).
4. Calcular peso del clasificador \( \alpha_t = 0.5 \ln((1-\epsilon_t)/\epsilon_t) \).
5. Actualizar pesos de instancias: \( w_i^{(t+1)} = w_i^{(t)} \cdot \exp(-\alpha_t y_i h_t(x_i)) \) y normalizar.
6. Ensemble final: \( H(x) = \text{sign}\left( \sum_{t=1}^T \alpha_t h_t(x) \right) \).

En la práctica, para detección de anomalías se suele utilizar un umbral de decisión ajustable (no necesariamente 0) para mejorar el recall de la clase minoritaria.

Ejemplo práctico: detección de fraudes en transacciones con datos sintéticos

A continuación se presenta una implementación conceptual de AdaBoost para detectar transacciones fraudulentas. Los datos sintéticos simulan 10,000 transacciones con 0.3% de anomalías. Se utiliza un stump de decisión como clasificador base.

Generación de datos sintéticos

Se crean dos clusters normales (transacciones legítimas) y un cluster pequeño y disperso (fraudes).

import numpy as np
from sklearn.datasets import make_blobs

# Muestras normales (99.7%)
X_normal, _ = make_blobs(n_samples=9970, centers=2, cluster_std=1.2, random_state=42)
y_normal = np.ones(len(X_normal))

# Muestras anómalas (0.3%)
X_anomaly, _ = make_blobs(n_samples=30, centers=1, cluster_std=2.5, random_state=42)
y_anomaly = -np.ones(len(X_anomaly))

X = np.vstack([X_normal, X_anomaly])
y = np.hstack([y_normal, y_anomaly])

Implementación manual de AdaBoost (núcleo)

class AdaBoostAnomaly:
    def __init__(self, n_estimators=50):
        self.n_estimators = n_estimators
        self.alphas = []
        self.models = []
        
    def fit(self, X, y):
        n = X.shape[0]
        w = np.ones(n) / n
        for _ in range(self.n_estimators):
            # clasificador débil: stump de decisión (DecisionTree con profundidad 1)
            stump = DecisionTreeClassifier(max_depth=1)
            stump.fit(X, y, sample_weight=w)
            y_pred = stump.predict(X)
            error = np.sum(w * (y_pred != y))
            if error == 0:
                error = 1e-10
            alpha = 0.5 * np.log((1 - error) / error)
            w = w * np.exp(-alpha * y * y_pred)
            w = w / np.sum(w)
            self.alphas.append(alpha)
            self.models.append(stump)
    
    def predict(self, X, threshold=0.0):
        # suma ponderada de votos
        preds = np.zeros(X.shape[0])
        for alpha, model in zip(self.alphas, self.models):
            preds += alpha * model.predict(X)
        return np.sign(preds - threshold)  # umbral ajustable

ajuste fino Umbral de decisión: Dado que las anomalías son raras, se recomienda usar un umbral negativo (ej. -0.5) para aumentar la sensibilidad. Esto se traduce en mayor recall a costa de ligeras falsas alarmas.

Evaluación del modelo: precisión, recall y F1-score

Se evalúa el rendimiento sobre un conjunto de prueba sintético (proporción similar de anomalías). Las métricas reflejan la capacidad de identificar fraudes.

Nota: Los valores numéricos corresponden a una simulación representativa. En un escenario real, se recomienda optimizar el umbral mediante validación cruzada y usar AUC-PR (área bajo la curva precisión-recall) como métrica principal, dado el fuerte desbalance.

Conclusiones y buenas prácticas

• AdaBoost es efectivo para anomalías cuando el número de clasificadores débiles es moderado (T entre 50 y 200). Demasiados estimadores pueden sobreajustar el ruido.
• Preprocesamiento crítico: eliminar outliers extremos que no sean anomalías reales (ruido) para evitar que el modelo se distorsione.
• Umbral de decisión: siempre ajustarlo según el coste de falsos positivos vs falsos negativos. En fraude bancario se toleran más falsas alarmas (umbral más bajo).
• Combinar con técnicas de remuestreo: submuestreo de la clase mayoritaria o SMOTE puede mejorar la estabilidad de AdaBoost.
• Métrica principal: utilizar F1-score y precisión-recall en lugar de exactitud (accuracy) debido al desbalance extremo.