scripts/leakdb_baselines.py

#!/usr/bin/env python3
"""Reference baseline detectors for LeakDB, ported from the original MATLAB code (Vrachimis et al., 2018).

Detectors
  null     never raises an alarm (lower bound for RTP / F1 / SED)
  random   independent fair coin per time step (seeded)
  mnf      Minimum Night Flow detector (`algorithmMNF.m`): for each day d, MNF(d) is the minimum inflow of
           the day; mMNF(d) is the minimum MNF over the last `window` days that were not flagged; day d is
           flagged (all 48 steps labelled 1) if MNF(d) - mMNF(d) > lam * mMNF(d). The first `window` days
           are never flagged. Note: the day's label is applied from 00:00, before that night's minimum has
           been observed, so the detector looks ahead by up to one day (as in the reference code).
  ideal    returns the ground-truth labels (upper bound, sanity check)

Network inflow used by MNF
  hanoi    flow_link_1 (the pipe from reservoir 1; identical to -demand_node_1) - as in the reference code
  net1     -(demand_node_9 + demand_node_2): water supplied by reservoir 9 and tank 2 (the reference code
           only covered Hanoi)

Usage
  # predictions for one detector (Parquet with scenario, time_index, prediction) for leakdb_score.py
  python leakdb_baselines.py predict --data hf://datasets/KIOSCoE/LeakDB --network hanoi --split test \
      --detector mnf --lam 0.2 --out mnf_hanoi_test.parquet

  # full benchmark: tune MNF on validation, report all baselines on test (and on all scenarios)
  python leakdb_baselines.py benchmark --data hf://datasets/KIOSCoE/LeakDB --json baselines.json --markdown baselines.md
"""
from __future__ import annotations

import argparse
import itertools
import json
import sys
import time

import numpy as np

from leakdb_score import iter_scenarios, score

STEPS_PER_DAY = 48
INFLOW_COLUMNS = {"hanoi": ["flow_link_1"], "net1": ["demand_node_9", "demand_node_2"]}


def network_inflow(network, df):
    if network == "hanoi":
        return df["flow_link_1"].to_numpy()
    if network == "net1":
        return -(df["demand_node_9"] + df["demand_node_2"]).to_numpy()
    raise ValueError(network)


# --------------------------------------------------------------------------------------------- detectors
def null_detector(n_steps):
    return np.zeros(n_steps, np.int8)


def random_detector(n_steps, rng):
    return rng.integers(0, 2, n_steps).astype(np.int8)


def mnf_detector(inflow, lam=0.2, window=10, steps_per_day=STEPS_PER_DAY):
    """Minimum Night Flow detector, a line-by-line port of algorithmMNF.m (w = window, gamma = lam)."""
    inflow = np.asarray(inflow, float)
    if len(inflow) % steps_per_day:
        raise ValueError("inflow length must be a whole number of days")
    mnf = inflow.reshape(-1, steps_per_day).min(axis=1)          # MATLAB: min(reshape(flow, 48, 365))
    k = list(range(window))                                       # days used for the reference minimum
    day_label = np.zeros(len(mnf), np.int8)
    for j in range(window, len(mnf)):
        ref = mnf[k].min()
        if mnf[j] - ref > ref * lam:
            day_label[j] = 1
        else:                                                     # unflagged days update the window
            k.append(j)
            k.pop(0)
    return np.repeat(day_label, steps_per_day)


# --------------------------------------------------------------------------------------------- data
def load(data, network, split):
    """Scenario ids, label matrix and inflow matrix for one network and split."""
    ids, labels, inflow = [], [], []
    for sid, df in iter_scenarios(data, network, split, columns=INFLOW_COLUMNS[network]):
        df = df.sort_values("time_index")
        ids.append(sid)
        labels.append(df["label"].to_numpy(np.int8))
        inflow.append(network_inflow(network, df))
    order = np.argsort(ids)
    return np.array(ids)[order], np.vstack(labels)[order], np.vstack(inflow)[order]


def run_detector(name, labels, inflow, lam=0.2, window=10, seed=0):
    n, T = labels.shape
    if name == "ideal":
        return labels.copy()
    if name == "null":
        return np.zeros((n, T), np.int8)
    if name == "random":
        rng = np.random.default_rng(seed)
        return np.vstack([random_detector(T, rng) for _ in range(n)])
    if name == "mnf":
        return np.vstack([mnf_detector(f, lam, window) for f in inflow])
    raise ValueError(name)


# --------------------------------------------------------------------------------------------- commands
def cmd_predict(args):
    import pandas as pd
    ids, labels, inflow = load(args.data, args.network, args.split)
    pred = run_detector(args.detector, labels, inflow, args.lam, args.window, args.seed)
    T = labels.shape[1]
    out = pd.DataFrame({"scenario": np.repeat(ids, T).astype(np.int16),
                        "time_index": np.tile(np.arange(1, T + 1, dtype=np.int32), len(ids)),
                        "prediction": pred.ravel()})
    out.to_parquet(args.out, index=False) if args.out.endswith(".parquet") else out.to_csv(args.out, index=False)
    print(f"wrote {len(out):,} predictions for {len(ids)} scenarios to {args.out}")


def _metrics(y, p):
    s = score(y, p)
    return {k: round(s[k], 2) for k in ("RTP", "RTN", "F1", "SED")} | {
        "events_detected": f"{s['n_events_detected']}/{s['n_events']}"}


def cmd_benchmark(args):
    lams = [round(x, 2) for x in np.arange(0.05, 0.501, 0.05)]
    windows = [5, 7, 10, 14, 21]
    results = {}
    for net in args.networks:
        t0 = time.time()
        data = {sp: load(args.data, net, sp) for sp in ("train", "validation", "test")}
        print(f"[{net}] loaded {sum(len(d[0]) for d in data.values())} scenarios in {time.time() - t0:.0f}s", flush=True)
        _, yv, fv = data["validation"]
        grid = []
        for w, lam in itertools.product(windows, lams):
            s = score(yv, run_detector("mnf", yv, fv, lam, w))
            grid.append(dict(window=w, lam=lam, F1=s["F1"], SED=s["SED"], RTP=s["RTP"], RTN=s["RTN"]))
        best = max(grid, key=lambda g: (g["F1"], g["SED"]))
        print(f"[{net}] MNF tuned on validation (max F1): window={best['window']} lam={best['lam']} "
              f"F1={best['F1']:.2f}", flush=True)

        detectors = [("Ideal", "ideal", {}), ("Null", "null", {}), ("Random", "random", {"seed": args.seed}),
                     ("MNF λ=0.10, w=10 (paper)", "mnf", {"lam": 0.10, "window": 10}),
                     ("MNF λ=0.20, w=10 (paper)", "mnf", {"lam": 0.20, "window": 10}),
                     ("MNF λ=0.30, w=10 (paper)", "mnf", {"lam": 0.30, "window": 10}),
                     (f"MNF λ={best['lam']:.2f}, w={best['window']} (tuned on validation)", "mnf",
                      {"lam": best["lam"], "window": best["window"]})]
        y_all = np.vstack([d[1] for d in data.values()])
        f_all = np.vstack([d[2] for d in data.values()])
        _, yt, ft = data["test"]
        rows = []
        for label, name, kw in detectors:
            rows.append(dict(detector=label,
                             test=_metrics(yt, run_detector(name, yt, ft, **kw)),
                             all_scenarios=_metrics(y_all, run_detector(name, y_all, f_all, **kw))))
        results[net] = dict(n_scenarios={sp: int(len(d[0])) for sp, d in data.items()},
                            tuning=dict(criterion="max F1 on validation", best=best, grid=grid), results=rows)
        print(f"[{net}] done in {time.time() - t0:.0f}s", flush=True)

    if args.json:
        with open(args.json, "w") as fh:
            json.dump(results, fh, indent=2, ensure_ascii=False)
    md = to_markdown(results)
    if args.markdown:
        with open(args.markdown, "w") as fh:
            fh.write(md)
    print(md)


def to_markdown(results):
    names = {"net1": "Net1_CMH", "hanoi": "Hanoi_CMH"}
    out = []
    for net, r in results.items():
        n = r["n_scenarios"]
        out.append(f"**{names.get(net, net)}** — test split ({n['test']} scenarios) and all {sum(n.values())} scenarios; scores in %.\n")
        out.append("| detector | RTP | RTN | F1 | SED | RTP (all) | RTN (all) | F1 (all) | SED (all) |")
        out.append("|---|---|---|---|---|---|---|---|---|")
        for row in r["results"]:
            t, a = row["test"], row["all_scenarios"]
            out.append(f"| {row['detector']} | {t['RTP']:.2f} | {t['RTN']:.2f} | {t['F1']:.2f} | {t['SED']:.2f} | "
                       f"{a['RTP']:.2f} | {a['RTN']:.2f} | {a['F1']:.2f} | {a['SED']:.2f} |")
        out.append("")
    return "\n".join(out)


def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = ap.add_subparsers(dest="cmd", required=True)
    p = sub.add_parser("predict", help="write predictions of one detector for one network/split")
    p.add_argument("--data", required=True, help="hf://datasets/<owner>/<repo> or a local dataset folder")
    p.add_argument("--network", required=True, choices=list(INFLOW_COLUMNS))
    p.add_argument("--split", default="test", choices=["train", "validation", "test"])
    p.add_argument("--detector", required=True, choices=["null", "random", "mnf", "ideal"])
    p.add_argument("--lam", type=float, default=0.2, help="MNF threshold gain (default 0.2)")
    p.add_argument("--window", type=int, default=10, help="MNF window in days (default 10)")
    p.add_argument("--seed", type=int, default=0)
    p.add_argument("--out", required=True, help=".parquet or .csv")
    b = sub.add_parser("benchmark", help="tune MNF on validation, score all baselines on test and on all scenarios")
    b.add_argument("--data", required=True)
    b.add_argument("--networks", nargs="+", default=["net1", "hanoi"], choices=list(INFLOW_COLUMNS))
    b.add_argument("--seed", type=int, default=0)
    b.add_argument("--json"); b.add_argument("--markdown")
    args = ap.parse_args(argv)
    {"predict": cmd_predict, "benchmark": cmd_benchmark}[args.cmd](args)


if __name__ == "__main__":
    sys.exit(main())