scripts/leakdb_score.py

#!/usr/bin/env python3
"""LeakDB scoring: a Python port of the reference MATLAB `scoring_algorithm.m`.

Scores binary leak predictions (one 0/1 value per scenario and 30-min time step) against the LeakDB labels,
with the metrics of Vrachimis et al. (2018), "LeakDB: a benchmark dataset for leakage diagnosis in water
distribution networks", WDSA/CCWI 2018:

  RTP   true-positive rate (recall) over all time steps of all scenarios, %         (paper eq. 2)
  RTN   true-negative rate (specificity), %                                         (eq. 3)
  F1    2TP / (2TP + FP + FN), with TP/FP/FN pooled over all scenarios, %           (eq. 4)
  SED   early-detection score: sum of per-event scores / number of events, %         (eq. 5, as in the code)
plus precision, accuracy and Matthews correlation (pooled) for convenience.

Early-detection score (as implemented in the reference code). For each leak event (a run of label 1) starting
at t_f and ending at t_e, the window is t_f ... t_e + 10 steps (5 h). Let x be the offset of the first
predicted 1 in the window. The event counts as detected only if more than 75 % of the predictions from that
first detection to the end of the window are 1; it then scores 2 / (1 + exp(alpha * x / tau)), where
tau = t_e - t_f + 10 and alpha = 5, otherwise 0. SED = sum of event scores / number of events.
(The paper text gives alpha = 6; the released MATLAB code, reproduced here, uses alpha = 5.)

The reference code divides by the number of events. The paper (eq. 6) instead normalises by the score of
the ideal detector, which is below 100 % because a perfect detector is silent during the 10-step extension
and short leaks then fail the 75 % persistence test; that variant is returned as `SED_ideal_normalised`.

`matlab_compat=True` reproduces the reference code exactly (verified against it in GNU Octave to 1e-12),
including one quirk: when an event ends less than 10 steps before the end of the year, the reference code
shortens the 10-step extension for that event *and for every later event in the matrix*, so scores depend
on scenario order. The default mode shortens it for that event only. In the 1000-scenario release 15 leaks
end that late, so use `--matlab-compat` only to reproduce numbers computed with the MATLAB code.

Usage as a library:
    from leakdb_score import score
    result = score(y_true, y_pred)           # arrays of shape (n_scenarios, n_steps) with 0/1 values

Usage from the command line (predictions as Parquet or CSV with columns scenario, time_index, prediction):
    python leakdb_score.py --predictions preds.parquet --network net1 --split test \
        --data hf://datasets/KIOSCoE/LeakDB            # or a local copy of the dataset repository
"""
from __future__ import annotations

import argparse
import json
import math
import sys

import numpy as np

EXTENSION_STEPS = 10      # tau_FP: 5 h at 30-min steps
PERSISTENCE = 0.75        # P%: detections must persist for > 75 % of the remaining window
ALPHA = 5.0               # sigmoid steepness used in the reference MATLAB code


def _as_matrix(x, name):
    a = np.asarray(x)
    if a.ndim == 1:
        a = a[None, :]
    if a.ndim != 2:
        raise ValueError(f"{name} must be 1-D or 2-D (scenarios x time steps)")
    if not np.isin(a, (0, 1)).all():
        raise ValueError(f"{name} must contain only 0 and 1")
    return a.astype(np.int8)


def confusion(y_true, y_pred):
    """Pooled confusion-matrix counts over all scenarios and time steps."""
    t, p = _as_matrix(y_true, "y_true"), _as_matrix(y_pred, "y_pred")
    if t.shape != p.shape:
        raise ValueError(f"shape mismatch: y_true {t.shape} vs y_pred {p.shape}")
    return dict(TP=int(((t == 1) & (p == 1)).sum()), TN=int(((t == 0) & (p == 0)).sum()),
                FP=int(((t == 0) & (p == 1)).sum()), FN=int(((t == 1) & (p == 0)).sum()))


def _events(labels, matlab_compat):
    """(start, end) index pairs (0-based, inclusive) of the runs of 1 in one scenario's labels."""
    if matlab_compat:   # reference code: starts from 0->1 transitions, ends from 1->0 transitions, paired by order
        d = np.diff(labels.astype(int))
        return list(zip(np.flatnonzero(d == 1) + 1, np.flatnonzero(d == -1)))
    d = np.diff(np.r_[0, labels.astype(int), 0])
    return list(zip(np.flatnonzero(d == 1), np.flatnonzero(d == -1) - 1))


def early_detection(y_true, y_pred, extension=EXTENSION_STEPS, persistence=PERSISTENCE, alpha=ALPHA,
                    matlab_compat=False, return_events=False):
    """Normalised early-detection score SED (%) and, optionally, the per-event scores."""
    t, p = _as_matrix(y_true, "y_true"), _as_matrix(y_pred, "y_pred")
    if t.shape != p.shape:
        raise ValueError(f"shape mismatch: y_true {t.shape} vs y_pred {p.shape}")
    n_steps = t.shape[1]
    ext_state = extension                      # matlab_compat: the reference code keeps shortening this
    total, events = 0.0, []
    for i in range(t.shape[0]):
        for start, end in _events(t[i], matlab_compat):
            if matlab_compat:
                if end + ext_state > n_steps - 1:
                    ext_state = n_steps - 1 - end
                ext = ext_state
            else:
                ext = min(extension, n_steps - 1 - end)
            tau = end - start + ext
            window = p[i, start:start + tau + 1]
            hits = np.flatnonzero(window == 1)
            s, delay = 0.0, None
            if len(hits):
                delay = int(hits[0])
                if window[delay:].mean() > persistence:
                    s = 1.0 if tau == 0 else 2.0 / (1.0 + math.exp(alpha / tau * delay))
                else:
                    delay = None
            total += s
            events.append(dict(row=i, start=int(start), end=int(end), delay=delay, score=s))
    sed = 100.0 * total / len(events) if events else float("nan")
    return (sed, events) if return_events else sed


def score(y_true, y_pred, matlab_compat=False, **sed_kwargs):
    """All LeakDB metrics (percentages) for 0/1 arrays of shape (n_scenarios, n_steps)."""
    c = confusion(y_true, y_pred)
    TP, TN, FP, FN = c["TP"], c["TN"], c["FP"], c["FN"]
    pct = lambda a, b: 100.0 * a / b if b else float("nan")
    denom = math.sqrt((TP + FP) * (TP + FN) * (TN + FP) * (TN + FN))
    sed, events = early_detection(y_true, y_pred, matlab_compat=matlab_compat, return_events=True, **sed_kwargs)
    sed_ideal = early_detection(y_true, y_true, matlab_compat=matlab_compat, **sed_kwargs)
    return dict(RTP=pct(TP, TP + FN), RTN=pct(TN, TN + FP), F1=pct(2 * TP, 2 * TP + FP + FN), SED=sed,
                SED_ideal_normalised=100.0 * sed / sed_ideal if sed_ideal else float("nan"),
                precision=pct(TP, TP + FP), accuracy=pct(TP + TN, TP + TN + FP + FN),
                MCC=(TP * TN - FP * FN) / denom if denom else float("nan"),
                n_scenarios=int(np.asarray(y_true).shape[0]) if np.asarray(y_true).ndim == 2 else 1,
                n_events=len(events), n_events_detected=sum(e["score"] > 0 for e in events), **c)


# ---------------------------------------------------------------------------------------------------------
# Loading ground truth from the Hugging Face dataset (or a local copy) and aligning predictions
# ---------------------------------------------------------------------------------------------------------
NETWORK_CONFIGS = {"net1": "net1_timeseries", "hanoi": "hanoi_timeseries"}


def _filesystem(root):
    if root.startswith("hf://"):
        from huggingface_hub import HfFileSystem
        return HfFileSystem(), root[len("hf://"):]
    import fsspec
    return fsspec.filesystem("file"), root


def list_split_files(root, network, split):
    fs, base = _filesystem(root.rstrip("/"))
    files = sorted(fs.glob(f"{base}/data/{NETWORK_CONFIGS[network]}/{split}-*.parquet"))
    if not files:
        raise FileNotFoundError(f"no files for {network}/{split} under {root}")
    return fs, files


def iter_scenarios(root, network, split, columns=()):
    """Yield (scenario_id, DataFrame) one scenario at a time (each Parquet row group is one scenario)."""
    import pyarrow.parquet as pq
    fs, files = list_split_files(root, network, split)
    cols = list(dict.fromkeys(["scenario", "time_index", "label", *columns]))
    for f in files:
        with fs.open(f, "rb") as fh:
            pf = pq.ParquetFile(fh)
            for g in range(pf.num_row_groups):
                df = pf.read_row_group(g, columns=cols).to_pandas()
                yield int(df["scenario"].iloc[0]), df


def load_labels(root, network, split):
    """(scenario ids, label matrix) for one network and split."""
    ids, rows = [], []
    for sid, df in iter_scenarios(root, network, split):
        ids.append(sid)
        rows.append(df.sort_values("time_index")["label"].to_numpy(np.int8))
    order = np.argsort(ids)
    return np.array(ids)[order], np.vstack(rows)[order]


def predictions_matrix(pred, scenario_ids, n_steps):
    """Pivot a predictions table (scenario, time_index, prediction) to a matrix aligned with scenario_ids."""
    import pandas as pd
    need = {"scenario", "time_index", "prediction"}
    if not need <= set(pred.columns):
        raise ValueError(f"predictions need columns {sorted(need)}, got {list(pred.columns)}")
    pred = pred[pred["scenario"].isin(scenario_ids)]
    missing = sorted(set(scenario_ids) - set(pred["scenario"].unique()))
    if missing:
        raise ValueError(f"predictions missing for {len(missing)} scenario(s), e.g. {missing[:10]}")
    m = pred.pivot_table(index="scenario", columns="time_index", values="prediction", aggfunc="first")
    m = m.reindex(index=scenario_ids, columns=range(1, n_steps + 1))
    if m.isna().any().any():
        raise ValueError(f"predictions missing for {int(m.isna().sum().sum())} (scenario, time_index) pairs")
    return m.to_numpy().astype(np.int8)


def _read_table(path):
    import pandas as pd
    return pd.read_parquet(path) if str(path).endswith(".parquet") else pd.read_csv(path)


def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--predictions", required=True, help="Parquet/CSV with columns scenario, time_index, prediction")
    ap.add_argument("--network", required=True, choices=list(NETWORK_CONFIGS))
    ap.add_argument("--split", default="test", choices=["train", "validation", "test"])
    ap.add_argument("--data", required=True, help="hf://datasets/<owner>/<repo> or a local dataset folder")
    ap.add_argument("--matlab-compat", action="store_true", help="reproduce the reference MATLAB code exactly")
    ap.add_argument("--json", help="also write the result to this JSON file")
    args = ap.parse_args(argv)

    ids, y_true = load_labels(args.data, args.network, args.split)
    y_pred = predictions_matrix(_read_table(args.predictions), ids, y_true.shape[1])
    result = dict(network=args.network, split=args.split, **score(y_true, y_pred, matlab_compat=args.matlab_compat))
    for k in ("RTP", "RTN", "F1", "SED"):
        print(f"{k:4s} {result[k]:7.2f} %")
    print(f"events detected: {result['n_events_detected']}/{result['n_events']}  "
          f"(scenarios: {result['n_scenarios']}, TP={result['TP']}, FP={result['FP']}, FN={result['FN']}, TN={result['TN']})")
    if args.json:
        with open(args.json, "w") as fh:
            json.dump(result, fh, indent=2)
    return result


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