Anomaly Detection in Delphi: Una Libreria Open Source per Rilevare l'Inaspettato

📦 In breve: La Delphi Anomaly Detection Library è una libreria open source gratuita che implementa 7 algoritmi per rilevare anomalie nei dati: Three Sigma, Sliding Window, EMA, Adaptive, Isolation Forest, DBSCAN e LOF. Permette di identificare frodi, errori, guasti e comportamenti anomali in applicazioni Delphi. È production-ready, thread-safe e supporta sia analisi real-time che batch. Repository GitHub.

Introduzione

“Prevenire è meglio che correggere” - questo antico detto si applica perfettamente al mondo dello sviluppo software e dei sistemi gestionali. Troppo spesso ci troviamo a inseguire problemi che avremmo potuto intercettare prima che causassero danni: ordini con importi sospetti, transazioni fraudolente, sensori malfunzionanti, picchi anomali di traffico, errori di data entry.

Il rilevamento di anomalie (anomaly detection) è quella branca della data science che si occupa di identificare pattern inaspettati, outlier e comportamenti anomali nei dati. Tecniche che fino a pochi anni fa erano appannaggio esclusivo di data scientist e ricercatori oggi possono essere integrate direttamente nei nostri applicativi gestionali, rendendoli più intelligenti, sicuri e affidabili.

È proprio di questo che ho parlato nel mio talk “Building Applications That Prevent Their Own Disasters” all’ITDevCon 2025, l’evento principale dell’anno per la community Delphi europea, tenutosi il 6 e 7 novembre a Milano. Ho anche presentato una versione ridotta in italiano dello stesso talk all’ITDevCon Bites di Padova a ottobre 2025. Il riscontro è stato straordinario: decine di sviluppatori si sono avvicinati raccontandomi scenari in cui queste tecniche avrebbero potuto salvare situazioni critiche o prevenire perdite economiche significative.

Da quella presentazione è nata l’idea di rilasciare una libreria open source completa, pronta all’uso, che permettesse alla community Delphi di integrare facilmente l’anomaly detection nei propri progetti. Oggi sono felice di annunciare che questa libreria è disponibile su GitHub.

La Libreria: Delphi Anomaly Detection Algorithms

La Delphi Anomaly Detection Library è una libreria completa che implementa 7 algoritmi diversi per il rilevamento di anomalie, coprendo scenari che vanno dall’analisi statistica classica fino al machine learning avanzato.

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

Caratteristiche Principali

• 7 Algoritmi di Rilevamento - Da semplici metodi statistici a tecniche ML avanzate
• Production Ready - Thread-safe, memory-efficient, testata al 100%
• Real-time & Batch - Supporta sia dati in streaming che analisi storiche
• Integrazione Semplice - Architettura modulare, zero dipendenze esterne
• Performance Monitoring - Metriche integrate e benchmarking
• Hyperparameter Tuning - Grid search e random search con cross-validation
• Factory Patterns - Detector pre-configurati per casi d’uso comuni

Gli Algoritmi: Quale Usare e Quando

La libreria implementa 7 algoritmi diversi, ognuno ottimizzato per scenari specifici. Ecco una panoramica rapida:

Vediamoli nel dettaglio.

Three Sigma Detector - Controllo Statistico di Processo

Il problema: In una linea di produzione manifatturiera, ogni componente deve rispettare tolleranze precise. Un cuscinetto con diametro di 100mm ± 0.5mm è accettabile; uno da 105mm è un difetto che può causare guasti a catena. Gli operatori non possono misurare manualmente ogni pezzo, e i difetti sfuggono fino a quando non causano problemi in assemblaggio o, peggio, dal cliente.

La soluzione: Il Three Sigma è l’algoritmo più classico e intuitivo. Calcola media e deviazione standard dei dati storici, poi considera anomalo tutto ciò che si discosta più di 3σ (sigma) dalla media. È la base del controllo qualità industriale usato da decenni.

var
  Detector: TThreeSigmaDetector;
  Result: TAnomalyResult;
begin
  Detector := TThreeSigmaDetector.Create;
  try
    // Aggiungi dati storici di produzione (diametri in mm)
    Detector.AddValues([100.2, 99.8, 100.5, 99.9, 100.1, 100.3, 99.7]);
    Detector.Build;

    // Verifica una nuova misurazione
    Result := Detector.Detect(105.5);
    if Result.IsAnomaly then
      ShowMessage('Anomalia rilevata in produzione!');
  finally
    Detector.Free;
  end;
end;

Sliding Window Detector - Monitoraggio Real-time

Il problema: Il tuo data center ospita server critici. La temperatura ambiente deve rimanere tra 18°C e 24°C. Un condizionatore che si guasta di notte può far salire la temperatura gradualmente - e quando te ne accorgi la mattina dopo, i server si sono già spenti per protezione termica. Hai bisogno di rilevare anomalie in tempo reale, su uno stream continuo di dati dai sensori.

La soluzione: Lo Sliding Window Detector mantiene una finestra scorrevole di dimensione fissa (es. ultimi 100 valori) e ricalcola le statistiche in tempo reale. Consuma memoria costante e si adatta naturalmente ai cambiamenti graduali (come il passaggio giorno/notte).

var
  Detector: TSlidingWindowDetector;
  Value: Double;
begin
  Detector := TSlidingWindowDetector.Create(100); // Finestra di 100 valori
  try
    // Inizializza con baseline
    Detector.InitializeWindow([21.5, 21.8, 22.0, 21.7, 21.9, 22.1, 21.6]);

    // Processa stream continuo dal sensore
    while HasIncomingData do
    begin
      Value := GetNextSensorReading;

      if Detector.Detect(Value).IsAnomaly then
        TriggerAlert('Temperatura fuori range: ' + Value.ToString + '°C');

      Detector.AddValue(Value); // Aggiorna finestra
    end;
  finally
    Detector.Free;
  end;
end;

EMA Detector - Adattamento Rapido

Il problema: Gestisci una piattaforma di trading. I prezzi delle azioni cambiano ogni millisecondo e devi rilevare movimenti anomali istantaneamente - un flash crash, uno spike improvviso, una manipolazione di mercato. Non puoi permetterti di mantenere in memoria milioni di valori storici, e i pattern di “normalità” cambiano continuamente durante la giornata.

La soluzione: L’Exponential Moving Average dà più peso ai valori recenti, dimenticando gradualmente il passato. Consuma memoria costante O(1) - letteralmente pochi byte - ed è velocissimo (~100k rilevamenti/sec). Perfetto per scenari ad altissima frequenza.

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

    // Monitora prezzi di borsa in tempo reale
    for Price in StockPrices do
    begin
      if Detector.Detect(Price).IsAnomaly then
      begin
        if Price > Detector.CurrentMean then
          LogAlert('Spike rilevato: ' + Price.ToString)
        else
          LogAlert('Crollo rilevato: ' + Price.ToString);
      end;
      Detector.AddValue(Price);
    end;
  finally
    Detector.Free;
  end;
end;

Adaptive Detector - Sistemi che Imparano

Il problema: Il tuo e-commerce ha pattern di traffico che cambiano nel tempo. A dicembre il carico è 10x rispetto a febbraio. Il Black Friday è un’anomalia… ma è un’anomalia attesa! Se il sistema segnala come anomalo ogni picco stagionale, gli operatori inizieranno a ignorare gli alert - e quando arriverà un vero problema, nessuno se ne accorgerà.

La soluzione: L’Adaptive Detector si adatta gradualmente ai nuovi pattern, imparando dal feedback dell’utente. Quando segnala un’anomalia, l’operatore può confermare “sì, è anomalo” oppure “no, è normale” - e il detector impara. Col tempo diventa sempre più accurato per il tuo specifico contesto.

var
  Detector: TAdaptiveAnomalyDetector;
  CPUUsage: Double;
begin
  Detector := TAdaptiveAnomalyDetector.Create(30, 0.05); // Finestra 30 giorni
  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 + '% - È normale?') then
          Detector.UpdateNormal(CPUUsage) // Insegna al detector
        else
          InvestigateCPUSpike;
      end
      else
        Detector.UpdateNormal(CPUUsage); // Apprende automaticamente
    end;
  finally
    Detector.Free;
  end;
end;

Isolation Forest - Machine Learning Multidimensionale

Il problema: Devi rilevare frodi su carte di credito. Una transazione da €5.000 è sospetta? Dipende. Se è un cliente premium che compra spesso gioielli, no. Se è un cliente che di solito spende €50 al supermercato, sì. E se quella transazione avviene alle 3 di notte da un paese estero? La “normalità” dipende da multiple variabili combinate - importo, ora, luogo, categoria, storico cliente.

La soluzione: L’Isolation Forest è un algoritmo di machine learning unsupervised che identifica anomalie in spazi multidimensionali. Costruisce “alberi di isolamento” che separano i punti: le anomalie, essendo rare e diverse, vengono isolate rapidamente. Non richiede di definire regole - impara dai dati.

var
  Detector: TIsolationForestDetector;
  Transaction: TArray<Double>;
begin
  Detector := TIsolationForestDetector.Create(100, 256, 5); // 100 alberi, 5 feature
  try
    // Training su transazioni normali
    for var i := 1 to 1000 do
    begin
      SetLength(Transaction, 5);
      Transaction[0] := RandomAmount;      // Importo
      Transaction[1] := RandomHour;        // Ora del giorno
      Transaction[2] := RandomDay;         // Giorno settimana
      Transaction[3] := RandomCategory;    // Categoria
      Transaction[4] := RandomAge;         // Età cliente

      Detector.AddTrainingData(Transaction);
    end;

    Detector.Train; // Costruisce il modello

    // Rileva transazione sospetta
    Transaction := [5000, 3, 2, 5, 35]; // €5000 alle 3 di notte
    if Detector.DetectMultiDimensional(Transaction).IsAnomaly then
      FlagForFraudReview('Fraud score alto!');
  finally
    Detector.Free;
  end;
end;

DBSCAN - Clustering Basato su Densità

Il problema: Gestisci una catena retail con decine di casse e cassieri. I furti interni sono difficili da rilevare: un cassiere disonesto può fare storni fittizi, applicare sconti non autorizzati, o annullare articoli dopo che il cliente ha pagato. Non puoi definire regole rigide (“mai più di 5 storni al giorno”) perché i pattern variano per punto vendita, turno, stagione. Ti serve un sistema che impari cosa è “normale” per ogni contesto.

La soluzione: DBSCAN (Density-Based Spatial Clustering of Applications with Noise) raggruppa automaticamente i comportamenti simili in cluster. I cassieri con pattern operativi normali formano gruppi densi; chi ha comportamenti anomali - troppi storni, sconti eccessivi, pattern di orario sospetti - finisce isolato come “rumore” e viene segnalato per verifica.

var
  Detector: TDBSCANDetector;
  CashierBehavior: TArray<Double>;
begin
  Detector := TDBSCANDetector.Create(
    0.3,  // Epsilon: raggio di vicinanza
    10    // MinPoints: minimo punti per formare un cluster
  );
  try
    // Training sui comportamenti storici dei cassieri
    // [storni_giorno, sconto_medio_%, scontrini_annullati, importo_medio]
    for var i := 1 to 5000 do
    begin
      CashierBehavior := [
        Random(5),           // 0-5 storni/giorno è normale
        Random(8),           // 0-8% sconto medio
        Random(3),           // 0-3 scontrini annullati
        50 + Random(150)     // €50-€200 importo medio
      ];
      Detector.AddTrainingData(CashierBehavior);
    end;

    Detector.Train;

    // Analizza il comportamento di un cassiere sospetto
    CashierBehavior := [12, 15, 8, 35]; // Troppi storni, sconti alti, molti annulli, importo basso
    if Detector.DetectMultiDimensional(CashierBehavior).IsAnomaly then
      FlagForAudit('Cassiere con pattern operativo anomalo - verificare');
  finally
    Detector.Free;
  end;
end;

Altro esempio classico: ordini a fornitori in un gestionale ERP. Gli ordini seguono pattern legati a stagionalità, quantità tipiche, fornitori abituali. Un ordine per materiale mai acquistato prima, verso un fornitore appena inserito in anagrafica, con importo e quantità insoliti, emerge automaticamente come anomalia - potenziale segnale di frode negli acquisti o errore di data entry.

LOF - Local Outlier Factor

Il problema: Vuoi prevenire il churn dei clienti premium. Un cliente che compra poco è normale se è un cliente occasionale. Ma se un cliente che spendeva €500/mese improvvisamente scende a €50/mese, è un segnale d’allarme - sta per abbandonarti. Il problema è che “poco” e “molto” sono relativi al segmento del cliente.

La soluzione: LOF (Local Outlier Factor) confronta ogni punto con i suoi “vicini” nel dataset. Un cliente premium che si comporta come un cliente occasionale ha un LOF alto - è anomalo rispetto al suo gruppo di riferimento, anche se il suo comportamento sarebbe normale per altri clienti.

var
  Detector: TLOFDetector;
  CustomerBehavior: TArray<Double>;
begin
  Detector := TLOFDetector.Create(20); // k=20 vicini
  try
    // Training su comportamenti clienti: [acquisti_mese, valore_medio, frequenza_login]
    for var i := 1 to 5000 do
    begin
      CustomerBehavior := [
        GetRandomPurchases,    // 1-50 acquisti/mese
        GetRandomAvgValue,     // €10-€500 valore medio
        GetRandomLoginFreq     // 1-30 login/mese
      ];
      Detector.AddTrainingData(CustomerBehavior);
    end;

    Detector.Train;

    // Cliente premium che improvvisamente si comporta come uno occasionale
    CustomerBehavior := [2, 450, 1]; // Pochi acquisti ma alto valore, raro login
    if Detector.DetectMultiDimensional(CustomerBehavior).IsAnomaly then
      FlagForChurnRisk('Possibile abbandono cliente premium');
  finally
    Detector.Free;
  end;
end;

Casi d’Uso Reali nei Gestionali

Vediamo scenari concreti dove questa libreria può fare la differenza.

Controllo Qualità in Produzione

In una linea di produzione manifatturiera, ogni componente deve rispettare tolleranze precise. Il Three Sigma detector identifica automaticamente i pezzi fuori specifica:

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('Diametro fuori tolleranza: ' + Diameter.ToString + 'mm');
    NotifyQualityTeam;
  end;

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

Risultato: Intercetti difetti prima che raggiungano l’assemblaggio o il cliente finale.

Monitoraggio Temperatura Data Center

I server critici devono operare in range di temperatura controllati. Lo Sliding Window detector monitora i sensori in tempo reale:

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('Sensore %s: temperatura anomala %.1f°C', [SensorID, Temperature]));
    if Temperature > 28 then
      ActivateEmergencyCooling;
  end;

  Detector.AddValue(Temperature);
end;

Risultato: Previeni shutdown termici e danni hardware prima che sia troppo tardi.

Rilevamento Frodi su Carte di Credito

Le transazioni fraudolente spesso hanno pattern multidimensionali anomali. L’Isolation Forest analizza simultaneamente importo, ora, luogo e comportamento storico:

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; // Blocca transazione
    FlagForManualReview('Transazione sospetta - fraud score elevato');
    NotifyFraudTeam;
  end
  else
    Result := True;
end;

Risultato: Blocchi frodi in tempo reale senza impattare i clienti legittimi.

Controllo Cassieri nel Retail

I furti interni sono difficili da rilevare con regole fisse. DBSCAN identifica automaticamente i cassieri con pattern operativi anomali:

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('Pattern operativo anomalo rilevato');
    GenerateDetailedReport(Behavior);
  end;
end;

Risultato: Rilevi frodi interne e comportamenti sospetti che sfuggirebbero ai controlli tradizionali.

Anomalie negli Ordini a Fornitori (ERP)

Gli ordini di acquisto seguono pattern prevedibili. Un ordine anomalo può indicare frode, errore o necessità di verifica:

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
  // [importo, quantità, anzianità_fornitore, categoria_merce]
  OrderFeatures := [Amount, Quantity, SupplierAge, CategoryCode];

  if FDetector.DetectMultiDimensional(OrderFeatures).IsAnomaly then
  begin
    Result := MessageDlg(
      'Ordine con caratteristiche insolite:' + sLineBreak +
      Format('Importo: €%.2f, Quantità: %.0f', [Amount, Quantity]) + sLineBreak +
      'Richiede approvazione manuale. Procedere?',
      mtWarning, [mbYes, mbNo], 0) = mrYes;

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

Risultato: Intercetti ordini fraudolenti, errori di data entry e situazioni che richiedono verifica.

Prevenzione Churn Clienti Premium

Il churn (abbandono) è quando un cliente smette di acquistare o cancella l’abbonamento. Rilevarlo in anticipo sui clienti premium - quelli ad alto valore - permette di intervenire prima che sia troppo tardi. LOF confronta ogni cliente con il suo gruppo di riferimento:

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 comportamento da cliente occasionale
    FlagChurnRisk(CustomerID, 'Alto rischio abbandono');
    TriggerRetentionCampaign(CustomerID);
    NotifyAccountManager(CustomerID);
  end;
end;

Risultato: Intervieni proattivamente prima che i clienti di valore abbandonino.

Monitoraggio Trading ad Alta Frequenza

I sistemi di trading devono rilevare anomalie in millisecondi. L’EMA detector è ottimizzato per scenari ad altissima frequenza:

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: prezzo +10% in un tick')
    else if Price < FPriceDetector.CurrentMean * 0.9 then
      LogAlert('CRASH: prezzo -10% in un tick');

    PauseAutomatedTrading; // Protezione
  end;

  if FVolumeDetector.Detect(Volume).IsAnomaly then
    LogAlert('Volume anomalo: possibile manipolazione');

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

Risultato: Proteggi i tuoi algoritmi da flash crash e manipolazioni di mercato.

Adattamento Stagionale E-commerce

Il traffico e-commerce varia drasticamente durante l’anno. L’Adaptive detector impara i pattern stagionali:

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
    // Chiedi conferma all'operatore
    if IsExpectedPeak then // Black Friday, Natale, etc.
    begin
      FTrafficDetector.UpdateNormal(Visitors); // Impara
      LogInfo('Picco atteso confermato');
    end
    else
    begin
      InvestigateTrafficAnomaly;
      LogWarning('Traffico anomalo non previsto');
    end;
  end
  else
    FTrafficDetector.UpdateNormal(Visitors);
end;

Risultato: Il sistema impara i tuoi pattern stagionali e smette di segnalare falsi positivi.

Data Entry Validation - Prevenire Errori Umani

Immagina un gestionale dove gli operatori inseriscono fatture. Con l’anomaly detection puoi avvisarli in tempo reale di importi sospetti:

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 per fornitore
  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('Importo insolito per %s: €%.2f' + sLineBreak +
             'Confermi l''inserimento?', [SupplierCode, Amount]),
      mtWarning, [mbYes, mbNo], 0) = mrYes;
  end
  else
    Result := True;

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

Risultato: Riduci errori di battitura (€10.000 invece di €1.000), importi duplicati, anomalie nei prezzi.

Sistema di Allerta DDoS

Proteggi i tuoi servizi web da attacchi distribuiti:

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

  while ServiceRunning do
  begin
    RequestsPerSecond := GetCurrentRPS;

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

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

Knight Capital Scenario - La Lezione da 440 Milioni

Nel talk all’ITDevCon ho raccontato il caso Knight Capital Group (2012): un bug software ha generato ordini anomali per 45 minuti, causando una perdita di 440 milioni di dollari e il fallimento dell’azienda.

Con anomaly detection questo disastro sarebbe stato evitabile:

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

  // Prima di ogni ordine
  if OrderVolumeDetector.IsAnomaly(OrderVolume) or
     OrderFrequencyDetector.IsAnomaly(OrdersPerSecond) then
  begin
    LogCritical('ANOMALIA TRADING RILEVATA!');
    HaltTradingSystem;
    NotifyRiskManagement;
    Exit; // Blocca l'ordine
  end;

  // Processa ordine normale...
end;

Un semplice check avrebbe salvato l’azienda.

Monitoraggio IoT e Manutenzione Predittiva

Sensori industriali che predicono guasti prima che accadano:

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 anomala motore');

  if FVibrationDetector.IsAnomaly(Vibration) then
    ScheduleMaintenance('Vibrazioni eccessive cuscinetto');

  if FPressureDetector.IsAnomaly(Pressure) then
    ScheduleMaintenance('Pressione idraulica fuori range');

  // Aggiorna i modelli
  FTempDetector.AddValue(Temp);
  FVibrationDetector.UpdateNormal(Vibration);
  FPressureDetector.AddValue(Pressure);
end;

Risultato: Riduci fermi macchina, previeni guasti catastrofici, ottimizzi manutenzione.

Valutazione e Ottimizzazione

La libreria include un framework completo per valutare l’accuratezza dei detector e ottimizzare automaticamente i parametri.

Evaluation Framework

Se hai dati etichettati (sai quali sono anomalie reali), puoi misurare le performance:

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 Automatico

Trova automaticamente i parametri ottimali:

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

    // Testa tutte le combinazioni
    BestConfig := Tuner.GridSearch(
      [2.0, 2.5, 3.0, 3.5], // Sigma values to test
      nil, nil, nil
    );

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

La libreria testa automaticamente decine di combinazioni e ti dice qual è la migliore per i tuoi dati.

Come Iniziare

Clona il repository:

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

Aggiungi le unit al tuo progetto e usa il factory pattern per iniziare subito:

uses
  AnomalyDetection.Types, AnomalyDetection.Factory;

var
  Detector: IAnomalyDetector;
begin
  // Factory pre-configurato per il tuo scenario
  Detector := Factory.CreateForFinancialData;  // Dati finanziari
  // Detector := Factory.CreateForWebTrafficMonitoring;  // Web security
  // Detector := Factory.CreateForIoTSensors;  // Sensori IoT

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

  if Detector.IsAnomaly(150) then
    ShowMessage('Anomalia rilevata!');
end;

La repository include demo complete per ogni algoritmo nella cartella Samples\, una suite di 84 test DUnitX con coverage al 100%, e segue principi SOLID per massima estensibilità. Tutti i detector sono thread-safe e ottimizzati per ambienti production (da ~20k a ~100k rilevamenti/sec a seconda dell’algoritmo).

Conclusioni

L’anomaly detection non è più appannaggio esclusivo di data scientist e grandi corporation. Con questa libreria puoi integrare intelligenza nei tuoi applicativi Delphi in pochi minuti, prevenendo errori, frodi, guasti e situazioni critiche.

La libreria è il risultato di mesi di lavoro, ricerca bibliografica, implementazione e testing. È stata progettata per essere production-ready fin da subito: thread-safe, performante, testata e documentata.

Che tu stia sviluppando un ERP, un sistema di monitoraggio industriale, una piattaforma finanziaria o un applicativo IoT, l’anomaly detection può fare la differenza tra un sistema reattivo (che scopre i problemi dopo) e uno proattivo (che li previene).

La libreria è open source e gratuita (licenza Apache 2.0). 🎓 È in preparazione un corso specifico su come utilizzare la libreria e come applicare gli algoritmi di anomaly detection nei tuoi progetti. 📄 Inoltre, a breve uscirà un Paper esclusivo per i supporter AllAccess+ su Patreon, con approfondimenti tecnici, comparazioni tra algoritmi e guide avanzate.

🏢 Per esigenze aziendali - training, workshop, consulenza o supporto enterprise - bit Time Professionals offre servizi di formazione e consulenza in italiano, inglese e spagnolo: professionals@bittime.it | www.bittimeprofessionals.com

Domande Frequenti (FAQ)

Cos’è l’anomaly detection?

L’anomaly detection (rilevamento di anomalie) è un insieme di tecniche che identificano automaticamente dati, eventi o comportamenti che si discostano significativamente dal pattern normale. Viene usato per rilevare frodi, guasti, errori di inserimento dati, intrusioni di sicurezza e qualsiasi situazione “fuori dall’ordinario”.

Quali algoritmi di anomaly detection sono disponibili nella libreria Delphi?

La libreria implementa 7 algoritmi:

1. Three Sigma - Controllo statistico classico basato su media e deviazione standard
2. Sliding Window - Monitoraggio real-time con finestra scorrevole
3. EMA (Exponential Moving Average) - Adattamento rapido per dati ad alta frequenza
4. Adaptive Detector - Sistema che impara dal feedback dell’utente
5. Isolation Forest - Machine learning per anomalie multidimensionali
6. DBSCAN - Clustering basato su densità per pattern complessi
7. LOF (Local Outlier Factor) - Confronto con vicini locali nel dataset

Quale algoritmo di anomaly detection devo usare?

La scelta dipende dallo scenario:

• Three Sigma: Controllo qualità, dati con distribuzione normale
• Sliding Window: Monitoraggio sensori, stream di dati continui
• EMA: Trading ad alta frequenza, dati che cambiano rapidamente
• Adaptive: Sistemi con stagionalità, pattern che evolvono nel tempo
• Isolation Forest: Frodi, transazioni con molte variabili
• DBSCAN: Clustering comportamentale, analisi cassieri/utenti
• LOF: Churn prediction, confronto tra gruppi di clienti

La libreria è gratuita?

Sì, la Delphi Anomaly Detection Library è completamente open source e gratuita con licenza Apache 2.0. Puoi usarla in progetti commerciali senza restrizioni.

È possibile usare l’anomaly detection in tempo reale?

Sì. Gli algoritmi Sliding Window, EMA e Adaptive sono ottimizzati per l’elaborazione in tempo reale su stream di dati. Supportano throughput da 20.000 a 100.000 rilevamenti al secondo.

Servono conoscenze di machine learning per usare la libreria?

No. La libreria include factory pre-configurati per scenari comuni (dati finanziari, sensori IoT, traffico web) che permettono di iniziare senza conoscere i dettagli degli algoritmi. Per chi vuole approfondire, è disponibile documentazione completa e un corso dedicato.

In quali settori si usa l’anomaly detection?

I casi d’uso più comuni includono:

• Finanza: Frodi carte di credito, trading anomalo
• Retail: Furti interni, comportamenti sospetti cassieri
• Manifattura: Controllo qualità, manutenzione predittiva
• IT: Sicurezza (DDoS, intrusioni), monitoraggio server
• Healthcare: Parametri vitali anomali, errori di dosaggio
• ERP: Validazione data entry, ordini sospetti

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

📖 Documentazione completa disponibile nel repository

💬 Domande? Apri una issue su GitHub

Daniele Teti

• Delphi
• DBSCAN
• LOF
• EMA