Anomalías en series temporales con Azure Anomaly Detector

Este tutorial muestra cómo detectar anomalías en series temporales con Azure Anomaly Detector, útil para monitorizar métricas como tráfico, ventas o telemetría. Aprende por qué se producen las detecciones, cómo preparar la serie, enviar solicitudes a la API y visualizar los puntos anómalos con un ejemplo en Python.

Requisitos previos

• Cuenta Azure con un recurso Azure Anomaly Detector creado (clave y endpoint).
• Python 3.8+ instalado y pip.
• Bibliotecas: requests, matplotlib, pandas (instalar en el paso 2).
• Fichero CSV o series temporales en formato timestamp+valor.

Paso 1: Crear el recurso Azure Anomaly Detector

En el portal Azure crea un recurso Azure Anomaly Detector (tipo de recurso: Anomaly Detector). Tras crear, copia la Key y el Endpoint. Necesitarás esos valores para autenticar las solicitudes HTTP.

Paso 2: Instalar dependencias y preparar datos

Instala las bibliotecas necesarias y prepara una pequeña serie temporal de ejemplo. La serie debe tener timestamps en ISO 8601 y valores numéricos. Aquí usamos un ejemplo sintético embebido en el código.

pip install requests pandas matplotlib

# exemplo_dataset.py
import pandas as pd
from datetime import datetime, timedelta

# Gerar 60 dias de dados com algumas anomalias
start = datetime(2023, 1, 1)
dates = [start + timedelta(days=i) for i in range(60)]
values = [100 + (i * 0.5) for i in range(60)]
# inserir anomalias artificiais
values[10] = 200
values[35] = 40

df = pd.DataFrame({'timestamp': [d.isoformat() for d in dates], 'value': values})
print(df.head())

Paso 3: Enviar la serie al endpoint Entire Detection

Usamos la API REST de Azure Anomaly Detector para detectar anomalías en toda la serie (Entire detection). El endpoint típico es: {endpoint}/anomalydetector/v1.1/timeseries/entire/detect. Sustituye YOUR_ENDPOINT y YOUR_KEY por tus valores.

import requests
import json
import pandas as pd

ENDPOINT = "https://YOUR_ENDPOINT"  # sem slash final
KEY = "YOUR_KEY"

# carregar dados do exemplo
from exemplo_dataset import df

url = f"{ENDPOINT}/anomalydetector/v1.1/timeseries/entire/detect"
headers = {
    'Content-Type': 'application/json',
    'Ocp-Apim-Subscription-Key': KEY
}

body = {
    'series': [{'timestamp': t, 'value': float(v)} for t, v in zip(df['timestamp'], df['value'])],
    'granularity': 'daily'
}

resp = requests.post(url, headers=headers, json=body)
resp.raise_for_status()
result = resp.json()
print(json.dumps(result, indent=2))

Paso 4: Interpretar la respuesta y aislar anomalías

La respuesta para Entire detection incluye arrays como isAnomaly, isPositiveAnomaly y anomalyScore. Itera sobre esos arrays para saber qué timestamps son anómalos.

# assumir 'result' do passo anterior
is_anomaly = result.get('isAnomaly', [])
anomaly_score = result.get('anomalyScore', [])

anomalies = []
for i, flag in enumerate(is_anomaly):
    if flag:
        anomalies.append({'timestamp': df.at[i, 'timestamp'], 'value': df.at[i, 'value'], 'score': anomaly_score[i] if anomaly_score else None})

print('Anomalias detectadas:', len(anomalies))
for a in anomalies:
    print(a)

Paso 5: Visualizar la serie y marcar las anomalías

Una visualización rápida ayuda a validar si las anomalías tienen sentido. Usa matplotlib para dibujar la serie y marcar los puntos anómalos en rojo.

import matplotlib.pyplot as plt

# preparar dados para plot
df['timestamp_dt'] = pd.to_datetime(df['timestamp'])

def plot_with_anomalies(df, anomalies):
    plt.figure(figsize=(10,4))
    plt.plot(df['timestamp_dt'], df['value'], label='valor')
    if anomalies:
        ann_ts = [pd.to_datetime(a['timestamp']) for a in anomalies]
        ann_vals = [a['value'] for a in anomalies]
        plt.scatter(ann_ts, ann_vals, color='red', label='anomalia', zorder=5)
    plt.xlabel('data')
    plt.ylabel('valor')
    plt.title('Série temporal com anomalias detectadas')
    plt.legend()
    plt.tight_layout()
    plt.show()

plot_with_anomalies(df, anomalies)

Verificar el resultado

Confirma que el número de anomalías es plausible: 1) imprime la lista de anomalías y verifica los timestamps; 2) compara los puntos rojos en el gráfico con picos/valles visibles; 3) si obtienes errores HTTP, verifica la clave, el endpoint y el formato JSON (Content-Type).

Conclusión

Con Azure Anomaly Detector puedes analizar series temporales rápidamente sin entrenar modelos. Próximos pasos: probar diferentes granularities (hourly, weekly), usar el sliding window endpoint para detección en streaming, e integrar en una pipeline con Azure Functions o Azure Machine Learning para alertas automáticas. Consejo: empieza validando con datos sintéticos (como aquí) antes de conectar la telemetría de producción — ¿qué métricas de tu aplicación quieres monitorizar primero?