Datasets:

KIOSCoE
/

LeakDB

#!/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)

	#!/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)