Datasets:

ranzouu
/

anomaly-detection-benchmark

#!/usr/bin/env python3
"""Gera um benchmark de detecção de anomalias com ground truth por construção.
Protocolo:
  1. sintetiza 180 dias de receita diária (tendência + sazonalidade semanal
     + ruído multiplicativo), tudo determinístico (seed fixa)
  2. injeta 12 anomalias em datas conhecidas (6 spikes, 6 quedas, magnitudes
     variadas) — ground truth perfeito por construção
  3. roda os detectores DO PRÓPRIO pacote (z-score, IQR, STL) sobre a série
  4. exporta precision/recall/F1 por método, por tipo (spike/queda) e por
     magnitude — nada de lógica de detecção duplicada aqui
Uso: python3 scripts/build_benchmark.py
Saídas: data/benchmark_metrics.json, data/benchmark_expected.json,
        runs/benchmark_records.csv, runs/benchmark_summary.csv,
        runs/benchmark_by_type.csv, runs/benchmark_by_magnitude.csv
"""
from __future__ import annotations

import csv
import json
from datetime import date, timedelta
from pathlib import Path

import numpy as np

ROOT = Path(__file__).resolve().parents[1]
DATA_DIR = ROOT / "data"
RUNS_DIR = ROOT / "runs"

SEED = 20260101
N_DAYS = 180
START = date(2025, 4, 1)
BASE = 120_000.0
TREND_PER_DAY = 0.0004
NOISE_SIGMA = 0.025

# (dia_index, tipo, fator) — spike multiplica, queda divide; >= 15 e deixa folga no fim
INJECTIONS = [
    (30, "spike", 2.6),
    (52, "spike", 2.3),
    (88, "spike", 3.2),
    (120, "spike", 2.4),
    (150, "spike", 2.8),
    (168, "spike", 2.5),
    (41, "drop", 0.70),
    (66, "drop", 0.62),
    (100, "drop", 0.72),
    (135, "drop", 0.58),
    (158, "drop", 0.68),
    (175, "drop", 0.75),
]
WEEKDAY_FACTOR = [1.02, 1.04, 1.03, 1.01, 0.99, 0.88, 0.86]  # seg..dom


def build_series() -> tuple[list[dict], dict[str, dict]]:
    rng = np.random.default_rng(SEED)
    points: list[dict] = []
    injection_map: dict[str, dict] = {}

    for i in range(N_DAYS):
        day = START + timedelta(days=i)
        clean = BASE * (1 + TREND_PER_DAY * i) * WEEKDAY_FACTOR[day.weekday()] * float(rng.normal(1.0, NOISE_SIGMA))
        value = clean
        for day_idx, kind, factor in INJECTIONS:
            if day_idx == i:
                value = clean * factor if kind == "spike" else clean * factor
                injection_map[day.isoformat()] = {
                    "type": kind,
                    "magnitude": factor if kind == "spike" else round(1 / factor, 2),
                    "factor": factor,
                }
        points.append({"date": day.isoformat(), "metric": "revenue", "value": round(value, 2)})

    # sanity: nenhuma inje colidindo
    assert len(injection_map) == len(INJECTIONS), "injeções colidiram em datas"
    return points, injection_map


def band_of(meta: dict) -> str:
    """Balde de magnitude definido DENTRO do tipo: fator de spike 2.3 e fator
    de queda 0.70 não vivem na mesma escala."""
    if meta["type"] == "spike":
        f = meta["factor"]
        return "spike >3.0x" if f > 3.0 else "spike 2.5-3.0x" if f >= 2.5 else "spike 2.0-2.5x"
    f = meta["factor"]
    return "queda >0.75" if f > 0.75 else "queda 0.65-0.75" if f >= 0.65 else "queda <0.65"


def main() -> int:
    from leadforge_anomaly_detector.experiment import run_detection_paths

    points, injection_map = build_series()

    DATA_DIR.mkdir(parents=True, exist_ok=True)
    RUNS_DIR.mkdir(parents=True, exist_ok=True)

    metrics_path = DATA_DIR / "benchmark_metrics.json"
    expected_path = DATA_DIR / "benchmark_expected.json"
    with open(metrics_path, "w", encoding="utf-8") as f:
        json.dump(points, f, ensure_ascii=False, indent=2)

    expected_rows = [
        {"date": d, "metric": "revenue", "is_anomaly": True, **meta} for d, meta in sorted(injection_map.items())
    ]
    with open(expected_path, "w", encoding="utf-8") as f:
        json.dump(expected_rows, f, ensure_ascii=False, indent=2)

    records, summary = run_detection_paths(metrics_path, expected_path)

    # records: predições por método (is_anomaly = predito). Cruza com o ground truth.
    records_csv = ROOT / "runs" / "benchmark_records.csv"
    with open(records_csv, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(
            f, fieldnames=["date", "metric", "value", "method", "score", "predicted", "expected", "expected_type", "expected_magnitude"]
        )
        writer.writeheader()
        for r in records:
            meta = injection_map.get(r.date)
            writer.writerow(
                {
                    "date": r.date,
                    "metric": r.metric,
                    "value": r.value,
                    "method": r.method,
                    "score": r.score,
                    "predicted": int(bool(r.is_anomaly)),
                    "expected": int(bool(meta)),
                    "expected_type": meta["type"] if meta else "",
                    "expected_magnitude": meta["magnitude"] if meta else "",
                }
            )

    # agregações por método
    methods = sorted({r.method for r in records})
    summary_rows, type_rows, magnitude_rows = [], [], []
    for method in methods:
        preds = [r for r in records if r.method == method]
        expected_set = set(injection_map)
        tp = [r for r in preds if r.is_anomaly and r.date in expected_set]
        fp = [r for r in preds if r.is_anomaly and r.date not in expected_set]
        fn_dates = expected_set - {r.date for r in preds if r.is_anomaly}
        precision = len(tp) / (len(tp) + len(fp)) if (len(tp) + len(fp)) else 0.0
        recall = len(tp) / (len(tp) + len(fn_dates)) if expected_set else 0.0
        f1 = 2 * precision * recall / (precision + recall) if (precision + recall) else 0.0
        summary_rows.append(
            {
                "method": method,
                "tp": len(tp),
                "fp": len(fp),
                "fn": len(fn_dates),
                "precision": round(precision, 4),
                "recall": round(recall, 4),
                "f1": round(f1, 4),
            }
        )
        # por tipo
        for kind in ("spike", "drop"):
            expected_kind = {d for d, m in injection_map.items() if m["type"] == kind}
            tp_kind = [r for r in preds if r.is_anomaly and r.date in expected_kind]
            type_rows.append(
                {
                    "method": method,
                    "anomaly_type": kind,
                    "detected": len(tp_kind),
                    "total": len(expected_kind),
                    "detection_rate": round(len(tp_kind) / len(expected_kind), 4),
                }
            )
        # por tipo e magnitude (baldes definidos dentro de cada tipo)
        bands = sorted({band_of(m) for m in injection_map.values()})
        for band_name in bands:
            expected_band = {d for d, m in injection_map.items() if band_of(m) == band_name}
            detected = [r for r in preds if r.is_anomaly and r.date in expected_band]
            magnitude_rows.append(
                {
                    "method": method,
                    "band": band_name,
                    "detected": len(detected),
                    "total": len(expected_band),
                    "detection_rate": round(len(detected) / len(expected_band), 4),
                }
            )

    def _dump(path: Path, rows: list[dict]) -> None:
        with open(path, "w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
            writer.writeheader()
            writer.writerows(rows)

    _dump(RUNS_DIR / "benchmark_summary.csv", summary_rows)
    _dump(RUNS_DIR / "benchmark_by_type.csv", type_rows)
    _dump(RUNS_DIR / "benchmark_by_magnitude.csv", magnitude_rows)

    print(f"sintetizados: {len(points)} pontos | injetadas: {len(injection_map)} anomalias | seed={SEED}")
    print("=== resumo por método (precision/recall/F1):")
    for row in summary_rows:
        print(f"  {row['method']:8s} P={row['precision']:.2f} R={row['recall']:.2f} F1={row['f1']:.2f} (tp={row['tp']} fp={row['fp']} fn={row['fn']})")
    print("=== por tipo (detection rate):")
    for row in type_rows:
        print(f"  {row['method']:8s} {row['anomaly_type']:5s} {row['detected']}/{row['total']}")
    print("=== por banda de magnitude:")
    for row in magnitude_rows:
        print(f"  {row['method']:8s} {row['band']:14s} {row['detected']}/{row['total']}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

	#!/usr/bin/env python3
	"""Gera um benchmark de detecção de anomalias com ground truth por construção.

	Protocolo:
	1. sintetiza 180 dias de receita diária (tendência + sazonalidade semanal
	+ ruído multiplicativo), tudo determinístico (seed fixa)
	2. injeta 12 anomalias em datas conhecidas (6 spikes, 6 quedas, magnitudes
	variadas) — ground truth perfeito por construção
	3. roda os detectores DO PRÓPRIO pacote (z-score, IQR, STL) sobre a série
	4. exporta precision/recall/F1 por método, por tipo (spike/queda) e por
	magnitude — nada de lógica de detecção duplicada aqui

	Uso: python3 scripts/build_benchmark.py
	Saídas: data/benchmark_metrics.json, data/benchmark_expected.json,
	runs/benchmark_records.csv, runs/benchmark_summary.csv,
	runs/benchmark_by_type.csv, runs/benchmark_by_magnitude.csv
	"""
	from __future__ import annotations

	import csv
	import json
	from datetime import date, timedelta
	from pathlib import Path

	import numpy as np

	ROOT = Path(__file__).resolve().parents[1]
	DATA_DIR = ROOT / "data"
	RUNS_DIR = ROOT / "runs"

	SEED = 20260101
	N_DAYS = 180
	START = date(2025, 4, 1)
	BASE = 120_000.0
	TREND_PER_DAY = 0.0004
	NOISE_SIGMA = 0.025

	# (dia_index, tipo, fator) — spike multiplica, queda divide; >= 15 e deixa folga no fim
	INJECTIONS = [
	(30, "spike", 2.6),
	(52, "spike", 2.3),
	(88, "spike", 3.2),
	(120, "spike", 2.4),
	(150, "spike", 2.8),
	(168, "spike", 2.5),
	(41, "drop", 0.70),
	(66, "drop", 0.62),
	(100, "drop", 0.72),
	(135, "drop", 0.58),
	(158, "drop", 0.68),
	(175, "drop", 0.75),
	]
	WEEKDAY_FACTOR = [1.02, 1.04, 1.03, 1.01, 0.99, 0.88, 0.86] # seg..dom


	def build_series() -> tuple[list[dict], dict[str, dict]]:
	rng = np.random.default_rng(SEED)
	points: list[dict] = []
	injection_map: dict[str, dict] = {}

	for i in range(N_DAYS):
	day = START + timedelta(days=i)
	clean = BASE * (1 + TREND_PER_DAY * i) * WEEKDAY_FACTOR[day.weekday()] * float(rng.normal(1.0, NOISE_SIGMA))
	value = clean
	for day_idx, kind, factor in INJECTIONS:
	if day_idx == i:
	value = clean * factor if kind == "spike" else clean * factor
	injection_map[day.isoformat()] = {
	"type": kind,
	"magnitude": factor if kind == "spike" else round(1 / factor, 2),
	"factor": factor,
	}
	points.append({"date": day.isoformat(), "metric": "revenue", "value": round(value, 2)})

	# sanity: nenhuma inje colidindo
	assert len(injection_map) == len(INJECTIONS), "injeções colidiram em datas"
	return points, injection_map


	def band_of(meta: dict) -> str:
	"""Balde de magnitude definido DENTRO do tipo: fator de spike 2.3 e fator
	de queda 0.70 não vivem na mesma escala."""
	if meta["type"] == "spike":
	f = meta["factor"]
	return "spike >3.0x" if f > 3.0 else "spike 2.5-3.0x" if f >= 2.5 else "spike 2.0-2.5x"
	f = meta["factor"]
	return "queda >0.75" if f > 0.75 else "queda 0.65-0.75" if f >= 0.65 else "queda <0.65"


	def main() -> int:
	from leadforge_anomaly_detector.experiment import run_detection_paths

	points, injection_map = build_series()

	DATA_DIR.mkdir(parents=True, exist_ok=True)
	RUNS_DIR.mkdir(parents=True, exist_ok=True)

	metrics_path = DATA_DIR / "benchmark_metrics.json"
	expected_path = DATA_DIR / "benchmark_expected.json"
	with open(metrics_path, "w", encoding="utf-8") as f:
	json.dump(points, f, ensure_ascii=False, indent=2)

	expected_rows = [
	{"date": d, "metric": "revenue", "is_anomaly": True, **meta} for d, meta in sorted(injection_map.items())
	]
	with open(expected_path, "w", encoding="utf-8") as f:
	json.dump(expected_rows, f, ensure_ascii=False, indent=2)

	records, summary = run_detection_paths(metrics_path, expected_path)

	# records: predições por método (is_anomaly = predito). Cruza com o ground truth.
	records_csv = ROOT / "runs" / "benchmark_records.csv"
	with open(records_csv, "w", newline="", encoding="utf-8") as f:
	writer = csv.DictWriter(
	f, fieldnames=["date", "metric", "value", "method", "score", "predicted", "expected", "expected_type", "expected_magnitude"]
	)
	writer.writeheader()
	for r in records:
	meta = injection_map.get(r.date)
	writer.writerow(
	{
	"date": r.date,
	"metric": r.metric,
	"value": r.value,
	"method": r.method,
	"score": r.score,
	"predicted": int(bool(r.is_anomaly)),
	"expected": int(bool(meta)),
	"expected_type": meta["type"] if meta else "",
	"expected_magnitude": meta["magnitude"] if meta else "",
	}
	)

	# agregações por método
	methods = sorted({r.method for r in records})
	summary_rows, type_rows, magnitude_rows = [], [], []
	for method in methods:
	preds = [r for r in records if r.method == method]
	expected_set = set(injection_map)
	tp = [r for r in preds if r.is_anomaly and r.date in expected_set]
	fp = [r for r in preds if r.is_anomaly and r.date not in expected_set]
	fn_dates = expected_set - {r.date for r in preds if r.is_anomaly}
	precision = len(tp) / (len(tp) + len(fp)) if (len(tp) + len(fp)) else 0.0
	recall = len(tp) / (len(tp) + len(fn_dates)) if expected_set else 0.0
	f1 = 2 * precision * recall / (precision + recall) if (precision + recall) else 0.0
	summary_rows.append(
	{
	"method": method,
	"tp": len(tp),
	"fp": len(fp),
	"fn": len(fn_dates),
	"precision": round(precision, 4),
	"recall": round(recall, 4),
	"f1": round(f1, 4),
	}
	)
	# por tipo
	for kind in ("spike", "drop"):
	expected_kind = {d for d, m in injection_map.items() if m["type"] == kind}
	tp_kind = [r for r in preds if r.is_anomaly and r.date in expected_kind]
	type_rows.append(
	{
	"method": method,
	"anomaly_type": kind,
	"detected": len(tp_kind),
	"total": len(expected_kind),
	"detection_rate": round(len(tp_kind) / len(expected_kind), 4),
	}
	)
	# por tipo e magnitude (baldes definidos dentro de cada tipo)
	bands = sorted({band_of(m) for m in injection_map.values()})
	for band_name in bands:
	expected_band = {d for d, m in injection_map.items() if band_of(m) == band_name}
	detected = [r for r in preds if r.is_anomaly and r.date in expected_band]
	magnitude_rows.append(
	{
	"method": method,
	"band": band_name,
	"detected": len(detected),
	"total": len(expected_band),
	"detection_rate": round(len(detected) / len(expected_band), 4),
	}
	)

	def _dump(path: Path, rows: list[dict]) -> None:
	with open(path, "w", newline="", encoding="utf-8") as f:
	writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
	writer.writeheader()
	writer.writerows(rows)

	_dump(RUNS_DIR / "benchmark_summary.csv", summary_rows)
	_dump(RUNS_DIR / "benchmark_by_type.csv", type_rows)
	_dump(RUNS_DIR / "benchmark_by_magnitude.csv", magnitude_rows)

	print(f"sintetizados: {len(points)} pontos \| injetadas: {len(injection_map)} anomalias \| seed={SEED}")
	print("=== resumo por método (precision/recall/F1):")
	for row in summary_rows:
	print(f" {row['method']:8s} P={row['precision']:.2f} R={row['recall']:.2f} F1={row['f1']:.2f} (tp={row['tp']} fp={row['fp']} fn={row['fn']})")
	print("=== por tipo (detection rate):")
	for row in type_rows:
	print(f" {row['method']:8s} {row['anomaly_type']:5s} {row['detected']}/{row['total']}")
	print("=== por banda de magnitude:")
	for row in magnitude_rows:
	print(f" {row['method']:8s} {row['band']:14s} {row['detected']}/{row['total']}")
	return 0


	if __name__ == "__main__":
	raise SystemExit(main())