Anomaly Detection en Delphi: Una Librería Open Source para Detectar lo Inesperado

📦 En resumen: La Delphi Anomaly Detection Library es una librería open source gratuita que implementa 7 algoritmos para detectar anomalías en datos: Three Sigma, Sliding Window, EMA, Adaptive, Isolation Forest, DBSCAN y LOF. Permite identificar fraudes, errores, fallos y comportamientos anómalos en aplicaciones Delphi. Es production-ready, thread-safe y soporta tanto análisis en tiempo real como batch. Repositorio GitHub.

Introducción

“Prevenir es mejor que curar” - este antiguo dicho se aplica perfectamente al mundo del desarrollo de software y los sistemas de gestión. Demasiado a menudo nos encontramos persiguiendo problemas que podríamos haber interceptado antes de que causaran daños: pedidos con importes sospechosos, transacciones fraudulentas, sensores que funcionan mal, picos anómalos de tráfico, errores de entrada de datos.

La detección de anomalías (anomaly detection) es la rama de la ciencia de datos que se ocupa de identificar patrones inesperados, outliers y comportamientos anómalos en los datos. Técnicas que hasta hace pocos años eran dominio exclusivo de científicos de datos e investigadores ahora pueden integrarse directamente en nuestras aplicaciones de gestión, haciéndolas más inteligentes, seguras y fiables.

Es exactamente de esto de lo que hablé en mi charla “Building Applications That Prevent Their Own Disasters” en ITDevCon 2025, el evento principal del año para la comunidad Delphi europea, celebrado el 6 y 7 de noviembre en Milán. También presenté una versión reducida en italiano de la misma charla en ITDevCon Bites en Padua en octubre de 2025. La respuesta fue extraordinaria: decenas de desarrolladores se acercaron contándome escenarios donde estas técnicas podrían haber salvado situaciones críticas o prevenido pérdidas económicas significativas.

De esa presentación nació la idea de lanzar una librería open source completa, lista para usar, que permitiera a la comunidad Delphi integrar fácilmente la detección de anomalías en sus proyectos. Hoy me alegra anunciar que esta librería está disponible en GitHub.

La Librería: Delphi Anomaly Detection Algorithms

La Delphi Anomaly Detection Library es una librería completa que implementa 7 algoritmos diferentes para la detección de anomalías, cubriendo escenarios que van desde el análisis estadístico clásico hasta el machine learning avanzado.

🔗 Repositorio GitHub: github.com/danieleteti/delphi-anomalies-detectors

Características Principales

• 7 Algoritmos de Detección - Desde métodos estadísticos simples hasta técnicas ML avanzadas
• Production Ready - Thread-safe, eficiente en memoria, testeada al 100%
• Real-time & Batch - Soporta tanto datos en streaming como análisis históricos
• Integración Simple - Arquitectura modular, cero dependencias externas
• Performance Monitoring - Métricas integradas y benchmarking
• Hyperparameter Tuning - Grid search y random search con cross-validation
• Factory Patterns - Detectores pre-configurados para casos de uso comunes

Los Algoritmos: Cuál Usar y Cuándo

La librería implementa 7 algoritmos diferentes, cada uno optimizado para escenarios específicos. Aquí una panorámica rápida:

Veámoslos en detalle.

Three Sigma Detector - Control Estadístico de Procesos

El problema: En una línea de producción manufacturera, cada componente debe cumplir tolerancias precisas. Un rodamiento con diámetro de 100mm ± 0.5mm es aceptable; uno de 105mm es un defecto que puede causar fallos en cascada. Los operadores no pueden medir manualmente cada pieza, y los defectos pasan desapercibidos hasta que causan problemas en el ensamblaje o, peor aún, en el cliente.

La solución: El Three Sigma es el algoritmo más clásico e intuitivo. Calcula la media y la desviación estándar de los datos históricos, luego considera anómalo todo lo que se desvía más de 3σ (sigma) de la media. Es la base del control de calidad industrial usado durante décadas.

var
  Detector: TThreeSigmaDetector;
  Result: TAnomalyResult;
begin
  Detector := TThreeSigmaDetector.Create;
  try
    // Añade datos históricos de producción (diámetros en mm)
    Detector.AddValues([100.2, 99.8, 100.5, 99.9, 100.1, 100.3, 99.7]);
    Detector.Build;

    // Verifica una nueva medición
    Result := Detector.Detect(105.5);
    if Result.IsAnomaly then
      ShowMessage('¡Anomalía detectada en producción!');
  finally
    Detector.Free;
  end;
end;

Sliding Window Detector - Monitoreo en Tiempo Real

El problema: Tu centro de datos aloja servidores críticos. La temperatura ambiente debe mantenerse entre 18°C y 24°C. Un aire acondicionado que falla por la noche puede hacer que la temperatura suba gradualmente - y cuando te das cuenta a la mañana siguiente, los servidores ya se han apagado por protección térmica. Necesitas detectar anomalías en tiempo real, sobre un stream continuo de datos de sensores.

La solución: El Sliding Window Detector mantiene una ventana deslizante de tamaño fijo (ej. últimos 100 valores) y recalcula las estadísticas en tiempo real. Consume memoria constante y se adapta naturalmente a cambios graduales (como la transición día/noche).

var
  Detector: TSlidingWindowDetector;
  Value: Double;
begin
  Detector := TSlidingWindowDetector.Create(100); // Ventana de 100 valores
  try
    // Inicializa con baseline
    Detector.InitializeWindow([21.5, 21.8, 22.0, 21.7, 21.9, 22.1, 21.6]);

    // Procesa stream continuo del sensor
    while HasIncomingData do
    begin
      Value := GetNextSensorReading;

      if Detector.Detect(Value).IsAnomaly then
        TriggerAlert('Temperatura fuera de rango: ' + Value.ToString + '°C');

      Detector.AddValue(Value); // Actualiza ventana
    end;
  finally
    Detector.Free;
  end;
end;

EMA Detector - Adaptación Rápida

El problema: Gestionas una plataforma de trading. Los precios de las acciones cambian cada milisegundo y necesitas detectar movimientos anómalos instantáneamente - un flash crash, un spike repentino, manipulación de mercado. No puedes permitirte mantener millones de valores históricos en memoria, y los patrones de “normalidad” cambian continuamente durante el día.

La solución: El Exponential Moving Average da más peso a los valores recientes, olvidando gradualmente el pasado. Consume memoria constante O(1) - literalmente unos pocos bytes - y es extremadamente rápido (~100k detecciones/seg). Perfecto para escenarios de ultra alta frecuencia.

var
  Detector: TEMAAnomalyDetector;
  Price: Double;
begin
  Detector := TEMAAnomalyDetector.Create(0.1); // Alpha = sensibilidad
  try
    // Warm-up con datos normales
    Detector.WarmUp([50.2, 50.5, 49.8, 50.1, 50.3]);

    // Monitorea precios de bolsa en tiempo real
    for Price in StockPrices do
    begin
      if Detector.Detect(Price).IsAnomaly then
      begin
        if Price > Detector.CurrentMean then
          LogAlert('Spike detectado: ' + Price.ToString)
        else
          LogAlert('Caída detectada: ' + Price.ToString);
      end;
      Detector.AddValue(Price);
    end;
  finally
    Detector.Free;
  end;
end;

Adaptive Detector - Sistemas que Aprenden

El problema: Tu e-commerce tiene patrones de tráfico que cambian con el tiempo. En diciembre la carga es 10x comparada con febrero. El Black Friday es una anomalía… ¡pero es una anomalía esperada! Si el sistema marca como anómalo cada pico estacional, los operadores empezarán a ignorar las alertas - y cuando llegue un problema real, nadie se dará cuenta.

La solución: El Adaptive Detector se adapta gradualmente a los nuevos patrones, aprendiendo del feedback del usuario. Cuando marca una anomalía, el operador puede confirmar “sí, es anómalo” o “no, es normal” - y el detector aprende. Con el tiempo se vuelve cada vez más preciso para tu contexto específico.

var
  Detector: TAdaptiveAnomalyDetector;
  CPUUsage: Double;
begin
  Detector := TAdaptiveAnomalyDetector.Create(30, 0.05); // Ventana 30 días
  try
    Detector.InitializeWithNormalData([45, 52, 48, 55, 50, 47, 53]);

    for var Day := 1 to 365 do
    begin
      CPUUsage := GetServerCPU;

      if Detector.Detect(CPUUsage).IsAnomaly then
      begin
        if UserConfirms('CPU alta: ' + CPUUsage.ToString + '% - ¿Es normal?') then
          Detector.UpdateNormal(CPUUsage) // Enseña al detector
        else
          InvestigateCPUSpike;
      end
      else
        Detector.UpdateNormal(CPUUsage); // Aprende automáticamente
    end;
  finally
    Detector.Free;
  end;
end;

Isolation Forest - Machine Learning Multidimensional

El problema: Necesitas detectar fraude en tarjetas de crédito. ¿Una transacción de €5.000 es sospechosa? Depende. Si es un cliente premium que compra joyas frecuentemente, no. Si es un cliente que normalmente gasta €50 en el supermercado, sí. ¿Y si esa transacción ocurre a las 3 de la madrugada desde un país extranjero? La “normalidad” depende de múltiples variables combinadas - importe, hora, ubicación, categoría, historial del cliente.

La solución: Isolation Forest es un algoritmo de machine learning no supervisado que identifica anomalías en espacios multidimensionales. Construye “árboles de aislamiento” que separan los puntos: las anomalías, al ser raras y diferentes, se aíslan rápidamente. No requiere definir reglas - aprende de los datos.

var
  Detector: TIsolationForestDetector;
  Transaction: TArray<Double>;
begin
  Detector := TIsolationForestDetector.Create(100, 256, 5); // 100 árboles, 5 features
  try
    // Training sobre transacciones normales
    for var i := 1 to 1000 do
    begin
      SetLength(Transaction, 5);
      Transaction[0] := RandomAmount;      // Importe
      Transaction[1] := RandomHour;        // Hora del día
      Transaction[2] := RandomDay;         // Día de la semana
      Transaction[3] := RandomCategory;    // Categoría
      Transaction[4] := RandomAge;         // Edad del cliente

      Detector.AddTrainingData(Transaction);
    end;

    Detector.Train; // Construye el modelo

    // Detecta transacción sospechosa
    Transaction := [5000, 3, 2, 5, 35]; // €5000 a las 3 de la madrugada
    if Detector.DetectMultiDimensional(Transaction).IsAnomaly then
      FlagForFraudReview('¡Puntuación de fraude alta!');
  finally
    Detector.Free;
  end;
end;

DBSCAN - Clustering Basado en Densidad

El problema: Gestionas una cadena retail con decenas de cajas y cajeros. Los robos internos son difíciles de detectar: un cajero deshonesto puede hacer devoluciones ficticias, aplicar descuentos no autorizados, o anular artículos después de que el cliente ha pagado. No puedes definir reglas rígidas (“nunca más de 5 devoluciones al día”) porque los patrones varían por tienda, turno y temporada. Necesitas un sistema que aprenda qué es “normal” para cada contexto.

La solución: DBSCAN (Density-Based Spatial Clustering of Applications with Noise) agrupa automáticamente los comportamientos similares en clusters. Los cajeros con patrones operativos normales forman grupos densos; los que tienen comportamientos anómalos - demasiadas devoluciones, descuentos excesivos, patrones de horario sospechosos - quedan aislados como “ruido” y se marcan para revisión.

var
  Detector: TDBSCANDetector;
  CashierBehavior: TArray<Double>;
begin
  Detector := TDBSCANDetector.Create(
    0.3,  // Epsilon: radio de vecindad
    10    // MinPoints: mínimo de puntos para formar un cluster
  );
  try
    // Training sobre comportamientos históricos de cajeros
    // [devoluciones_dia, descuento_medio_%, tickets_anulados, importe_medio]
    for var i := 1 to 5000 do
    begin
      CashierBehavior := [
        Random(5),           // 0-5 devoluciones/día es normal
        Random(8),           // 0-8% descuento medio
        Random(3),           // 0-3 tickets anulados
        50 + Random(150)     // €50-€200 importe medio
      ];
      Detector.AddTrainingData(CashierBehavior);
    end;

    Detector.Train;

    // Analiza el comportamiento de un cajero sospechoso
    CashierBehavior := [12, 15, 8, 35]; // Demasiadas devoluciones, descuentos altos, muchas anulaciones, importe bajo
    if Detector.DetectMultiDimensional(CashierBehavior).IsAnomaly then
      FlagForAudit('Cajero con patrón operativo anómalo - verificar');
  finally
    Detector.Free;
  end;
end;

Otro ejemplo clásico: pedidos a proveedores en un sistema ERP. Los pedidos siguen patrones relacionados con estacionalidad, cantidades típicas y proveedores habituales. Un pedido de material nunca comprado antes, a un proveedor recién añadido a la base de datos, con importes y cantidades inusuales, emerge automáticamente como anomalía - potencial señal de fraude en compras o error de entrada de datos.

LOF - Local Outlier Factor

El problema: Quieres prevenir el abandono de clientes premium. Un cliente que compra poco es normal si es un cliente ocasional. Pero si un cliente que gastaba €500/mes de repente baja a €50/mes, es una señal de alarma - está a punto de abandonarte. El problema es que “poco” y “mucho” son relativos al segmento del cliente.

La solución: LOF (Local Outlier Factor) compara cada punto con sus “vecinos” en el dataset. Un cliente premium comportándose como un cliente ocasional tiene un LOF alto - es anómalo respecto a su grupo de referencia, aunque su comportamiento sería normal para otros clientes.

var
  Detector: TLOFDetector;
  CustomerBehavior: TArray<Double>;
begin
  Detector := TLOFDetector.Create(20); // k=20 vecinos
  try
    // Training sobre comportamientos de clientes: [compras_mes, valor_medio, frecuencia_login]
    for var i := 1 to 5000 do
    begin
      CustomerBehavior := [
        GetRandomPurchases,    // 1-50 compras/mes
        GetRandomAvgValue,     // €10-€500 valor medio
        GetRandomLoginFreq     // 1-30 logins/mes
      ];
      Detector.AddTrainingData(CustomerBehavior);
    end;

    Detector.Train;

    // Cliente premium que de repente se comporta como uno ocasional
    CustomerBehavior := [2, 450, 1]; // Pocas compras pero alto valor, login raro
    if Detector.DetectMultiDimensional(CustomerBehavior).IsAnomaly then
      FlagForChurnRisk('Posible abandono de cliente premium');
  finally
    Detector.Free;
  end;
end;

Casos de Uso Reales en Sistemas de Gestión

Veamos escenarios concretos donde esta librería puede marcar la diferencia.

Control de Calidad en Producción

En una línea de producción manufacturera, cada componente debe cumplir tolerancias precisas. El detector Three Sigma identifica automáticamente las piezas fuera de especificación:

type
  TQualityController = class
  private
    FDiameterDetector: TThreeSigmaDetector;
    FWeightDetector: TThreeSigmaDetector;
  public
    procedure CheckComponent(Diameter, Weight: Double);
  end;

procedure TQualityController.CheckComponent(Diameter, Weight: Double);
begin
  if FDiameterDetector.Detect(Diameter).IsAnomaly then
  begin
    RejectComponent('Diámetro fuera de tolerancia: ' + Diameter.ToString + 'mm');
    NotifyQualityTeam;
  end;

  if FWeightDetector.Detect(Weight).IsAnomaly then
  begin
    RejectComponent('Peso fuera de rango: ' + Weight.ToString + 'g');
    NotifyQualityTeam;
  end;
end;

Resultado: Interceptas defectos antes de que lleguen al ensamblaje o al cliente final.

Monitoreo de Temperatura en Data Center

Los servidores críticos deben operar en rangos de temperatura controlados. El detector Sliding Window monitorea los sensores en tiempo real:

type
  TDataCenterMonitor = class
  private
    FSensors: TDictionary<string, TSlidingWindowDetector>;
  public
    procedure ProcessReading(SensorID: string; Temperature: Double);
  end;

procedure TDataCenterMonitor.ProcessReading(SensorID: string; Temperature: Double);
var
  Detector: TSlidingWindowDetector;
begin
  if not FSensors.TryGetValue(SensorID, Detector) then
  begin
    Detector := TSlidingWindowDetector.Create(100);
    FSensors.Add(SensorID, Detector);
  end;

  if Detector.Detect(Temperature).IsAnomaly then
  begin
    TriggerAlert(Format('Sensor %s: temperatura anómala %.1f°C', [SensorID, Temperature]));
    if Temperature > 28 then
      ActivateEmergencyCooling;
  end;

  Detector.AddValue(Temperature);
end;

Resultado: Previenes apagados térmicos y daños al hardware antes de que sea demasiado tarde.

Detección de Fraude en Tarjetas de Crédito

Las transacciones fraudulentas suelen tener patrones multidimensionales anómalos. Isolation Forest analiza simultáneamente importe, hora, ubicación y comportamiento histórico:

type
  TFraudDetector = class
  private
    FDetector: TIsolationForestDetector;
  public
    function CheckTransaction(Amount, Hour, DayOfWeek, Category,
      CustomerAge: Double): Boolean;
  end;

function TFraudDetector.CheckTransaction(Amount, Hour, DayOfWeek,
  Category, CustomerAge: Double): Boolean;
var
  Features: TArray<Double>;
begin
  Features := [Amount, Hour, DayOfWeek, Category, CustomerAge];

  if FDetector.DetectMultiDimensional(Features).IsAnomaly then
  begin
    Result := False; // Bloquea la transacción
    FlagForManualReview('Transacción sospechosa - puntuación de fraude alta');
    NotifyFraudTeam;
  end
  else
    Result := True;
end;

Resultado: Bloqueas fraudes en tiempo real sin impactar a los clientes legítimos.

Control de Cajeros en Retail

Los robos internos son difíciles de detectar con reglas fijas. DBSCAN identifica automáticamente a los cajeros con patrones operativos anómalos:

type
  TCashierAudit = class
  private
    FDetector: TDBSCANDetector;
  public
    procedure AnalyzeCashier(RefundsPerDay, AvgDiscountPct,
      VoidedReceipts, AvgTransactionAmount: Double);
  end;

procedure TCashierAudit.AnalyzeCashier(RefundsPerDay, AvgDiscountPct,
  VoidedReceipts, AvgTransactionAmount: Double);
var
  Behavior: TArray<Double>;
begin
  Behavior := [RefundsPerDay, AvgDiscountPct, VoidedReceipts, AvgTransactionAmount];

  if FDetector.DetectMultiDimensional(Behavior).IsAnomaly then
  begin
    FlagForAudit('Patrón operativo anómalo detectado');
    GenerateDetailedReport(Behavior);
  end;
end;

Resultado: Detectas fraudes internos y comportamientos sospechosos que escaparían a los controles tradicionales.

Anomalías en Pedidos a Proveedores (ERP)

Los pedidos de compra siguen patrones predecibles. Un pedido anómalo puede indicar fraude, error o necesidad de verificación:

type
  TPurchaseOrderValidator = class
  private
    FDetector: TDBSCANDetector;
  public
    function ValidateOrder(Amount, Quantity: Double;
      SupplierAge, CategoryCode: Integer): Boolean;
  end;

function TPurchaseOrderValidator.ValidateOrder(Amount, Quantity: Double;
  SupplierAge, CategoryCode: Integer): Boolean;
var
  OrderFeatures: TArray<Double>;
begin
  // [importe, cantidad, antigüedad_proveedor, categoría_mercancía]
  OrderFeatures := [Amount, Quantity, SupplierAge, CategoryCode];

  if FDetector.DetectMultiDimensional(OrderFeatures).IsAnomaly then
  begin
    Result := MessageDlg(
      'Pedido con características inusuales:' + sLineBreak +
      Format('Importe: €%.2f, Cantidad: %.0f', [Amount, Quantity]) + sLineBreak +
      'Requiere aprobación manual. ¿Proceder?',
      mtWarning, [mbYes, mbNo], 0) = mrYes;

    if not Result then
      LogSuspiciousOrder(OrderFeatures);
  end
  else
    Result := True;
end;

Resultado: Interceptas pedidos fraudulentos, errores de entrada de datos y situaciones que requieren verificación.

Prevención del Abandono de Clientes Premium (Churn)

El churn (abandono) ocurre cuando un cliente deja de comprar o cancela su suscripción. Detectarlo anticipadamente en clientes premium - aquellos de alto valor - permite intervenir antes de que sea demasiado tarde. LOF compara cada cliente con su grupo de referencia:

type
  TChurnPredictor = class
  private
    FDetector: TLOFDetector;
  public
    procedure AnalyzeCustomer(PurchasesPerMonth, AvgOrderValue,
      LoginFrequency: Double; CustomerID: Integer);
  end;

procedure TChurnPredictor.AnalyzeCustomer(PurchasesPerMonth, AvgOrderValue,
  LoginFrequency: Double; CustomerID: Integer);
var
  Behavior: TArray<Double>;
begin
  Behavior := [PurchasesPerMonth, AvgOrderValue, LoginFrequency];

  if FDetector.DetectMultiDimensional(Behavior).IsAnomaly then
  begin
    // Cliente premium con comportamiento de cliente ocasional
    FlagChurnRisk(CustomerID, 'Alto riesgo de abandono');
    TriggerRetentionCampaign(CustomerID);
    NotifyAccountManager(CustomerID);
  end;
end;

Resultado: Intervienes proactivamente antes de que los clientes valiosos te abandonen.

Monitoreo de Trading de Alta Frecuencia

Los sistemas de trading deben detectar anomalías en milisegundos. El detector EMA está optimizado para escenarios de ultra alta frecuencia:

type
  TTradingMonitor = class
  private
    FPriceDetector: TEMAAnomalyDetector;
    FVolumeDetector: TEMAAnomalyDetector;
  public
    procedure CheckMarketData(Price, Volume: Double);
  end;

procedure TTradingMonitor.CheckMarketData(Price, Volume: Double);
begin
  if FPriceDetector.Detect(Price).IsAnomaly then
  begin
    if Price > FPriceDetector.CurrentMean * 1.1 then
      LogAlert('SPIKE: precio +10% en un tick')
    else if Price < FPriceDetector.CurrentMean * 0.9 then
      LogAlert('CRASH: precio -10% en un tick');

    PauseAutomatedTrading; // Protección
  end;

  if FVolumeDetector.Detect(Volume).IsAnomaly then
    LogAlert('Volumen anómalo: posible manipulación');

  FPriceDetector.AddValue(Price);
  FVolumeDetector.AddValue(Volume);
end;

Resultado: Proteges tus algoritmos de flash crashes y manipulaciones de mercado.

Adaptación Estacional de E-commerce

El tráfico de e-commerce varía drásticamente durante el año. El detector Adaptive aprende los patrones estacionales:

type
  TEcommerceMonitor = class
  private
    FTrafficDetector: TAdaptiveAnomalyDetector;
  public
    procedure ProcessDailyTraffic(Visitors: Integer);
  end;

procedure TEcommerceMonitor.ProcessDailyTraffic(Visitors: Integer);
begin
  if FTrafficDetector.Detect(Visitors).IsAnomaly then
  begin
    // Pide confirmación al operador
    if IsExpectedPeak then // Black Friday, Navidad, etc.
    begin
      FTrafficDetector.UpdateNormal(Visitors); // Aprende
      LogInfo('Pico esperado confirmado');
    end
    else
    begin
      InvestigateTrafficAnomaly;
      LogWarning('Anomalía de tráfico no esperada');
    end;
  end
  else
    FTrafficDetector.UpdateNormal(Visitors);
end;

Resultado: El sistema aprende tus patrones estacionales y deja de señalar falsos positivos.

Validación de Entrada de Datos - Prevenir Errores Humanos

Imagina un sistema de gestión donde los operadores introducen facturas. Con la detección de anomalías puedes alertarlos en tiempo real sobre importes sospechosos:

type
  TInvoiceValidator = class
  private
    FDetectors: TDictionary<string, TSlidingWindowDetector>;
  public
    function ValidateAmount(SupplierCode: string; Amount: Double): Boolean;
  end;

function TInvoiceValidator.ValidateAmount(SupplierCode: string;
  Amount: Double): Boolean;
var
  Detector: TSlidingWindowDetector;
begin
  // Un detector por proveedor
  if not FDetectors.TryGetValue(SupplierCode, Detector) then
  begin
    Detector := TSlidingWindowDetector.Create(50);
    FDetectors.Add(SupplierCode, Detector);
  end;

  if Detector.Detect(Amount).IsAnomaly then
  begin
    Result := MessageDlg(
      Format('Importe inusual para %s: €%.2f' + sLineBreak +
             '¿Confirmas la entrada?', [SupplierCode, Amount]),
      mtWarning, [mbYes, mbNo], 0) = mrYes;
  end
  else
    Result := True;

  if Result then
    Detector.AddValue(Amount); // Aprende
end;

Resultado: Reduce errores de escritura (€10.000 en lugar de €1.000), importes duplicados, anomalías en precios.

Sistema de Alerta DDoS

Protege tus servicios web de ataques distribuidos:

var
  TrafficDetector: TSlidingWindowDetector;
begin
  TrafficDetector := TSlidingWindowDetector.Create(60); // 1 minuto

  while ServiceRunning do
  begin
    RequestsPerSecond := GetCurrentRPS;

    if TrafficDetector.Detect(RequestsPerSecond).IsAnomaly then
    begin
      LogSecurity('Posible DDoS: ' + RequestsPerSecond.ToString + ' req/s');
      EnableRateLimiting;
      NotifySecurityTeam;
    end;

    TrafficDetector.AddValue(RequestsPerSecond);
    Sleep(1000);
  end;
end;

Escenario Knight Capital - La Lección de 440 Millones

En mi charla de ITDevCon conté el caso de Knight Capital Group (2012): un bug de software generó órdenes anómalas durante 45 minutos, causando una pérdida de 440 millones de dólares y la quiebra de la empresa.

Con detección de anomalías este desastre habría sido evitable:

var
  OrderVolumeDetector: TEMAAnomalyDetector;
  OrderFrequencyDetector: TSlidingWindowDetector;
begin
  OrderVolumeDetector := TEMAAnomalyDetector.Create(0.05);
  OrderFrequencyDetector := TSlidingWindowDetector.Create(100);

  // Antes de cada orden
  if OrderVolumeDetector.IsAnomaly(OrderVolume) or
     OrderFrequencyDetector.IsAnomaly(OrdersPerSecond) then
  begin
    LogCritical('¡ANOMALÍA DE TRADING DETECTADA!');
    HaltTradingSystem;
    NotifyRiskManagement;
    Exit; // Bloquea la orden
  end;

  // Procesa orden normal...
end;

Un simple check habría salvado la empresa.

Monitoreo IoT y Mantenimiento Predictivo

Sensores industriales que predicen fallos antes de que ocurran:

type
  TSensorMonitor = class
  private
    FTempDetector: TEMAAnomalyDetector;
    FVibrationDetector: TAdaptiveAnomalyDetector;
    FPressureDetector: TSlidingWindowDetector;
  public
    procedure ProcessSensorData(Temp, Vibration, Pressure: Double);
  end;

procedure TSensorMonitor.ProcessSensorData(Temp, Vibration, Pressure: Double);
begin
  if FTempDetector.IsAnomaly(Temp) then
    ScheduleMaintenance('Temperatura anómala del motor');

  if FVibrationDetector.IsAnomaly(Vibration) then
    ScheduleMaintenance('Vibraciones excesivas del rodamiento');

  if FPressureDetector.IsAnomaly(Pressure) then
    ScheduleMaintenance('Presión hidráulica fuera de rango');

  // Actualiza los modelos
  FTempDetector.AddValue(Temp);
  FVibrationDetector.UpdateNormal(Vibration);
  FPressureDetector.AddValue(Pressure);
end;

Resultado: Reduce paradas de máquina, previene fallos catastróficos, optimiza el mantenimiento.

Evaluación y Optimización

La librería incluye un framework completo para evaluar la precisión de los detectores y optimizar automáticamente los parámetros.

Framework de Evaluación

Si tienes datos etiquetados (sabes cuáles son anomalías reales), puedes medir el rendimiento:

uses AnomalyDetection.Evaluation;

var
  Dataset: TLabeledDataset;
  Evaluator: TAnomalyDetectorEvaluator;
  Result: TEvaluationResult;
begin
  Dataset := TLabeledDataset.Create('Test Production Data');
  Dataset.LoadFromCSV('sensor_data.csv', 0, 1, True);

  Detector := TSlidingWindowDetector.Create(100);
  Evaluator := TAnomalyDetectorEvaluator.Create(Detector, Dataset);
  try
    Result := Evaluator.Evaluate;

    WriteLn('Accuracy:  ', Result.ConfusionMatrix.GetAccuracy:0:3);
    WriteLn('Precision: ', Result.ConfusionMatrix.GetPrecision:0:3);
    WriteLn('Recall:    ', Result.ConfusionMatrix.GetRecall:0:3);
    WriteLn('F1-Score:  ', Result.ConfusionMatrix.GetF1Score:0:3);
  finally
    Evaluator.Free;
  end;
end;

Hyperparameter Tuning Automático

Encuentra automáticamente los parámetros óptimos:

var
  Tuner: THyperparameterTuner;
  BestConfig: TTuningResult;
begin
  Tuner := THyperparameterTuner.Create(adtThreeSigma, Dataset);
  try
    Tuner.OptimizationMetric := 'F1';

    // Testea todas las combinaciones
    BestConfig := Tuner.GridSearch(
      [2.0, 2.5, 3.0, 3.5], // Valores de sigma a probar
      nil, nil, nil
    );

    ShowMessage(Format('Mejor sigma: %.2f (F1: %.3f)',
      [BestConfig.Config.SigmaMultiplier, BestConfig.Score]));
  finally
    Tuner.Free;
  end;
end;

La librería testea automáticamente decenas de combinaciones y te dice cuál es la mejor para tus datos.

Cómo Empezar

Clona el repositorio:

git clone https://github.com/danieleteti/delphi-anomalies-detectors.git

Añade las units a tu proyecto y usa el factory pattern para empezar inmediatamente:

uses
  AnomalyDetection.Types, AnomalyDetection.Factory;

var
  Detector: IAnomalyDetector;
begin
  // Factory pre-configurado para tu escenario
  Detector := Factory.CreateForFinancialData;  // Datos financieros
  // Detector := Factory.CreateForWebTrafficMonitoring;  // Seguridad web
  // Detector := Factory.CreateForIoTSensors;  // Sensores IoT

  Detector.AddValues([100, 105, 98, 102, 107, 99, 103]);
  Detector.Build;

  if Detector.IsAnomaly(150) then
    ShowMessage('¡Anomalía detectada!');
end;

El repositorio incluye demos completas para cada algoritmo en la carpeta Samples\, una suite de 84 tests DUnitX con cobertura del 100%, y sigue principios SOLID para máxima extensibilidad. Todos los detectores son thread-safe y optimizados para entornos de producción (~20k a ~100k detecciones/seg según el algoritmo).

Conclusiones

La detección de anomalías ya no es dominio exclusivo de científicos de datos y grandes corporaciones. Con esta librería puedes integrar inteligencia en tus aplicaciones Delphi en minutos, previniendo errores, fraudes, fallos y situaciones críticas.

La librería es el resultado de meses de trabajo, investigación bibliográfica, implementación y testing. Fue diseñada para ser production-ready desde el primer día: thread-safe, performante, testeada y documentada.

Ya sea que estés desarrollando un ERP, un sistema de monitoreo industrial, una plataforma financiera o una aplicación IoT, la detección de anomalías puede marcar la diferencia entre un sistema reactivo (que descubre los problemas después) y uno proactivo (que los previene).

La librería es open source y gratuita (licencia Apache 2.0). 🎓 Está en preparación un curso específico sobre cómo usar la librería y aplicar los algoritmos de detección de anomalías en tus proyectos. 📄 Además, próximamente saldrá un Paper exclusivo para los supporters AllAccess+ en Patreon, con profundizaciones técnicas, comparaciones entre algoritmos y guías avanzadas.

🏢 Para necesidades empresariales - training, workshops, consultoría o soporte enterprise - bit Time Professionals ofrece servicios de formación y consultoría en italiano, inglés y español: professionals@bittime.it | www.bittimeprofessionals.com

Preguntas Frecuentes (FAQ)

¿Qué es la detección de anomalías (anomaly detection)?

La detección de anomalías es un conjunto de técnicas que identifican automáticamente datos, eventos o comportamientos que se desvían significativamente del patrón normal. Se usa para detectar fraudes, fallos, errores de entrada de datos, intrusiones de seguridad y cualquier situación “fuera de lo ordinario”.

¿Qué algoritmos de detección de anomalías están disponibles en la librería Delphi?

La librería implementa 7 algoritmos:

1. Three Sigma - Control estadístico clásico basado en media y desviación estándar
2. Sliding Window - Monitoreo en tiempo real con ventana deslizante
3. EMA (Exponential Moving Average) - Adaptación rápida para datos de alta frecuencia
4. Adaptive Detector - Sistema que aprende del feedback del usuario
5. Isolation Forest - Machine learning para anomalías multidimensionales
6. DBSCAN - Clustering basado en densidad para patrones complejos
7. LOF (Local Outlier Factor) - Comparación con vecinos locales en el dataset

¿Qué algoritmo de detección de anomalías debo usar?

La elección depende del escenario:

• Three Sigma: Control de calidad, datos con distribución normal
• Sliding Window: Monitoreo de sensores, streams de datos continuos
• EMA: Trading de alta frecuencia, datos que cambian rápidamente
• Adaptive: Sistemas con estacionalidad, patrones que evolucionan
• Isolation Forest: Fraudes, transacciones con muchas variables
• DBSCAN: Clustering comportamental, análisis de cajeros/usuarios
• LOF: Predicción de abandono (churn), comparación entre grupos de clientes

¿La librería es gratuita?

Sí, la Delphi Anomaly Detection Library es completamente open source y gratuita con licencia Apache 2.0. Puedes usarla en proyectos comerciales sin restricciones.

¿Se puede usar la detección de anomalías en tiempo real?

Sí. Los algoritmos Sliding Window, EMA y Adaptive están optimizados para procesamiento en tiempo real sobre streams de datos. Soportan throughput de 20.000 a 100.000 detecciones por segundo.

¿Necesito conocimientos de machine learning para usar la librería?

No. La librería incluye factories pre-configurados para escenarios comunes (datos financieros, sensores IoT, tráfico web) que permiten empezar sin conocer los detalles de los algoritmos. Para quienes quieran profundizar, hay documentación completa y un curso dedicado disponible.

¿En qué sectores se usa la detección de anomalías?

Los casos de uso más comunes incluyen:

• Finanzas: Fraude en tarjetas de crédito, trading anómalo
• Retail: Robos internos, comportamientos sospechosos de cajeros
• Manufactura: Control de calidad, mantenimiento predictivo
• IT: Seguridad (DDoS, intrusiones), monitoreo de servidores
• Sanidad: Parámetros vitales anómalos, errores de dosificación
• ERP: Validación de entrada de datos, pedidos sospechosos

🔗 Repositorio GitHub: github.com/danieleteti/delphi-anomalies-detectors

📖 Documentación completa disponible en el repositorio

💬 ¿Preguntas? Abre una issue en GitHub

Daniele Teti

• Delphi
• DBSCAN
• LOF
• EMA