Upload essd_scripts/snr_filter_diagnostic.py

essd_scripts/snr_filter_diagnostic.py

@@ -0,0 +1,399 @@
+#!/usr/bin/env python3
+"""SNR-threshold diagnostics for continuous picker outputs.
+
+This script tests a narrow claim: SNR filtering changes the operating point, but
+it is not a substitute for continuous, denominator-aware evaluation. It reports
+how SNR thresholds trade recall against continuous pick burden, and can write
+SNR-filtered picker JSONL files for downstream association checks.
+"""
+
+from __future__ import annotations
+
+import argparse
+import bisect
+import csv
+import json
+import math
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+PHASE_MAP = {
+    "P": ["Pg"],
+    "S": ["Sg"],
+}
+
+
+def parse_utc_to_epoch_seconds(value: str) -> float:
+    text = str(value).strip()
+    if text.endswith("Z"):
+        text = text[:-1] + "+00:00"
+    dt = datetime.fromisoformat(text)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    else:
+        dt = dt.astimezone(timezone.utc)
+    return dt.timestamp()
+
+
+def norm_location(value: str | None) -> str:
+    if value is None or value == "":
+        return "--"
+    return str(value)
+
+
+def norm_station_id(
+    station_id: str | None = None,
+    network: str | None = None,
+    station: str | None = None,
+    location: str | None = None,
+) -> str:
+    if station_id:
+        parts = str(station_id).split(".")
+        if len(parts) >= 3:
+            return f"{parts[0]}.{parts[1]}.{norm_location(parts[2])}"
+        return str(station_id)
+    return f"{network}.{station}.{norm_location(location)}"
+
+
+def iter_jsonl(path: Path):
+    with path.open("r", encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def in_time_window(epoch: float, start_epoch: float | None, end_epoch: float | None) -> bool:
+    if start_epoch is not None and epoch < start_epoch:
+        return False
+    if end_epoch is not None and epoch >= end_epoch:
+        return False
+    return True
+
+
+def label_key(rec: dict[str, Any], ordinal: int) -> str:
+    return "|".join(
+        [
+            str(ordinal),
+            str(rec.get("event_id")),
+            str(rec.get("station_id")),
+            str(rec.get("label_phase")),
+            f"{float(rec.get('label_time_epoch')):.3f}",
+        ]
+    )
+
+
+def load_labels(
+    matches_jsonl: Path,
+    start_epoch: float | None,
+    end_epoch: float | None,
+) -> list[dict[str, Any]]:
+    labels = []
+    ordinal = 0
+    for rec in iter_jsonl(matches_jsonl):
+        if rec.get("subset") != "all":
+            continue
+        if not rec.get("has_waveform"):
+            continue
+        phase = str(rec.get("label_phase"))
+        if phase not in PHASE_MAP:
+            continue
+        try:
+            epoch = float(rec["label_time_epoch"])
+        except Exception:
+            continue
+        if not in_time_window(epoch, start_epoch, end_epoch):
+            continue
+        ordinal += 1
+        key = label_key(rec, ordinal)
+        labels.append(
+            {
+                "key": key,
+                "event_id": rec.get("event_id"),
+                "station_id": norm_station_id(str(rec.get("station_id") or "")),
+                "label_phase": phase,
+                "label_time_epoch": epoch,
+            }
+        )
+    return labels
+
+
+def percentile(values: list[float], q: float) -> float | None:
+    if not values:
+        return None
+    values = sorted(values)
+    if len(values) == 1:
+        return values[0]
+    pos = (len(values) - 1) * q
+    lo = math.floor(pos)
+    hi = math.ceil(pos)
+    if lo == hi:
+        return values[int(pos)]
+    return values[lo] * (hi - pos) + values[hi] * (pos - lo)
+
+
+def nearest_pick(
+    picks: list[dict[str, Any]],
+    starts: list[float],
+    label_time_epoch: float,
+    threshold: float,
+    err_window_s: float,
+) -> dict[str, Any] | None:
+    left = bisect.bisect_left(starts, label_time_epoch - err_window_s)
+    right = bisect.bisect_right(starts, label_time_epoch + err_window_s)
+    best = None
+    best_abs = None
+    for item in picks[left:right]:
+        if item["snr"] < threshold:
+            continue
+        residual = item["time_epoch"] - label_time_epoch
+        abs_residual = abs(residual)
+        if best is None or abs_residual < best_abs:
+            best = {**item, "residual_s": residual}
+            best_abs = abs_residual
+    return best
+
+
+def sweep_pick_metrics(args: argparse.Namespace) -> None:
+    thresholds = sorted(set(float(x) for x in args.thresholds))
+    start_epoch = parse_utc_to_epoch_seconds(args.starttime) if args.starttime else None
+    end_epoch = parse_utc_to_epoch_seconds(args.endtime) if args.endtime else None
+    labels = load_labels(args.matches_jsonl, start_epoch, end_epoch)
+
+    auto_counts = {threshold: Counter() for threshold in thresholds}
+    indexed: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
+    stats = Counter()
+
+    auto_to_label_phase = {}
+    for label_phase, auto_phases in PHASE_MAP.items():
+        for auto_phase in auto_phases:
+            auto_to_label_phase[auto_phase] = label_phase
+
+    for rec in iter_jsonl(args.picks_jsonl):
+        if rec.get("record_type") != "phase_pick":
+            stats[f"skip_record_type:{rec.get('record_type', '')}"] += 1
+            continue
+        stats["phase_pick_records"] += 1
+        try:
+            epoch = parse_utc_to_epoch_seconds(rec["phase_time"])
+            snr = float(rec["snr"])
+        except Exception:
+            stats["skip_bad_time_or_snr"] += 1
+            continue
+        if not in_time_window(epoch, start_epoch, end_epoch):
+            stats["skip_outside_time_window"] += 1
+            continue
+        phase = str(rec.get("phase_name") or "")
+        for threshold in thresholds:
+            if snr >= threshold:
+                auto_counts[threshold][phase] += 1
+        label_phase = auto_to_label_phase.get(phase)
+        if label_phase is None:
+            continue
+        station_info = rec.get("station_info") or {}
+        station_id = norm_station_id(
+            rec.get("station_id") or station_info.get("station_id"),
+            station_info.get("network"),
+            station_info.get("station"),
+            station_info.get("location"),
+        )
+        indexed[(station_id, label_phase)].append(
+            {
+                "time_epoch": epoch,
+                "snr": snr,
+                "phase_prob": rec.get("phase_prob"),
+                "phase_name": phase,
+            }
+        )
+
+    starts_by_key = {}
+    for key, values in indexed.items():
+        values.sort(key=lambda item: item["time_epoch"])
+        starts_by_key[key] = [item["time_epoch"] for item in values]
+
+    baseline_keys: set[str] = set()
+    rows = []
+    for threshold in thresholds:
+        tp = 0
+        matched_keys = set()
+        residuals = []
+        tp_snr = []
+        for lab in labels:
+            key = (lab["station_id"], lab["label_phase"])
+            pick = nearest_pick(
+                indexed.get(key, []),
+                starts_by_key.get(key, []),
+                lab["label_time_epoch"],
+                threshold,
+                args.err_window_s,
+            )
+            if pick is None:
+                continue
+            residual = float(pick["residual_s"])
+            if abs(residual) <= args.tp_tol_s:
+                tp += 1
+                matched_keys.add(lab["key"])
+                residuals.append(abs(residual))
+                tp_snr.append(float(pick["snr"]))
+        if threshold == thresholds[0]:
+            baseline_keys = set(matched_keys)
+        total_auto = int(sum(auto_counts[threshold].values()))
+        lost_from_baseline = len(baseline_keys - matched_keys) if baseline_keys else 0
+        row = {
+            "snr_threshold": threshold,
+            "automatic_picks": total_auto,
+            "automatic_pick_counts_by_phase": dict(sorted(auto_counts[threshold].items())),
+            "n_label_with_waveform": len(labels),
+            "n_tp_with_waveform": tp,
+            "coverage_aware_recall": tp / len(labels) if labels else None,
+            "catalog_relative_matched_fraction": tp / total_auto if total_auto else None,
+            "automatic_picks_per_covered_tp": total_auto / tp if tp else None,
+            "tp_retained_from_baseline_fraction": (
+                len(matched_keys & baseline_keys) / len(baseline_keys)
+                if baseline_keys
+                else None
+            ),
+            "baseline_tp_lost": lost_from_baseline,
+            "abs_residual_p95_s": percentile(residuals, 0.95),
+            "tp_snr_median": percentile(tp_snr, 0.50),
+        }
+        rows.append(row)
+
+    out = {
+        "diagnostic": "snr_threshold_pick_sweep",
+        "picks_jsonl": str(args.picks_jsonl),
+        "matches_jsonl": str(args.matches_jsonl),
+        "time_window": {
+            "starttime": args.starttime,
+            "endtime": args.endtime,
+        },
+        "matching": {
+            "phase_map": PHASE_MAP,
+            "tp_tolerance_s": args.tp_tol_s,
+            "search_window_s": args.err_window_s,
+            "waveform_covered_labels_only": True,
+        },
+        "stats": dict(sorted(stats.items())),
+        "rows": rows,
+    }
+    args.output_json.parent.mkdir(parents=True, exist_ok=True)
+    args.output_json.write_text(json.dumps(out, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    if args.output_tsv:
+        args.output_tsv.parent.mkdir(parents=True, exist_ok=True)
+        fields = [
+            "snr_threshold",
+            "automatic_picks",
+            "n_label_with_waveform",
+            "n_tp_with_waveform",
+            "coverage_aware_recall",
+            "catalog_relative_matched_fraction",
+            "automatic_picks_per_covered_tp",
+            "tp_retained_from_baseline_fraction",
+            "baseline_tp_lost",
+            "abs_residual_p95_s",
+            "tp_snr_median",
+        ]
+        with args.output_tsv.open("w", encoding="utf-8", newline="") as handle:
+            writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t")
+            writer.writeheader()
+            for row in rows:
+                writer.writerow({field: row.get(field) for field in fields})
+
+    print(f"[OK] labels with waveform: {len(labels)}")
+    print(f"[OK] thresholds: {', '.join(str(x) for x in thresholds)}")
+    print(f"[OK] wrote: {args.output_json}")
+    if args.output_tsv:
+        print(f"[OK] wrote: {args.output_tsv}")
+
+
+def filter_snr_jsonl(args: argparse.Namespace) -> None:
+    start_epoch = parse_utc_to_epoch_seconds(args.starttime) if args.starttime else None
+    end_epoch = parse_utc_to_epoch_seconds(args.endtime) if args.endtime else None
+    stats = Counter()
+    kept_by_phase = Counter()
+
+    args.output_jsonl.parent.mkdir(parents=True, exist_ok=True)
+    with args.output_jsonl.open("w", encoding="utf-8") as out:
+        for rec in iter_jsonl(args.picks_jsonl):
+            stats["input_records"] += 1
+            if rec.get("record_type") != "phase_pick":
+                stats[f"skip_record_type:{rec.get('record_type', '')}"] += 1
+                continue
+            try:
+                epoch = parse_utc_to_epoch_seconds(rec["phase_time"])
+                snr = float(rec["snr"])
+            except Exception:
+                stats["skip_bad_time_or_snr"] += 1
+                continue
+            if not in_time_window(epoch, start_epoch, end_epoch):
+                stats["skip_outside_time_window"] += 1
+                continue
+            stats["phase_pick_records_in_time_window"] += 1
+            if snr < args.snr_threshold:
+                stats["skip_below_snr_threshold"] += 1
+                continue
+            stats["kept_records"] += 1
+            kept_by_phase[str(rec.get("phase_name") or "")] += 1
+            out.write(json.dumps(rec, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+    summary = {
+        "diagnostic": "snr_filtered_pick_jsonl",
+        "picks_jsonl": str(args.picks_jsonl),
+        "output_jsonl": str(args.output_jsonl),
+        "time_window": {
+            "starttime": args.starttime,
+            "endtime": args.endtime,
+        },
+        "snr_threshold": args.snr_threshold,
+        "kept_pick_counts": {
+            "total": int(stats["kept_records"]),
+            "by_phase": dict(sorted(kept_by_phase.items())),
+        },
+        "stats": dict(sorted(stats.items())),
+    }
+    args.summary_json.parent.mkdir(parents=True, exist_ok=True)
+    args.summary_json.write_text(json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8")
+    print(f"[OK] SNR >= {args.snr_threshold}: kept {stats['kept_records']} picks")
+    print(f"[OK] wrote: {args.output_jsonl}")
+    print(f"[OK] summary: {args.summary_json}")
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_sweep = sub.add_parser("sweep-pick-metrics", help="Sweep SNR thresholds for pick-level metrics.")
+    p_sweep.add_argument("--picks-jsonl", type=Path, required=True)
+    p_sweep.add_argument("--matches-jsonl", type=Path, required=True)
+    p_sweep.add_argument("--output-json", type=Path, required=True)
+    p_sweep.add_argument("--output-tsv", type=Path, default=None)
+    p_sweep.add_argument("--thresholds", type=float, nargs="+", default=[0, 1, 1.5, 2, 3, 5])
+    p_sweep.add_argument("--starttime", default=None)
+    p_sweep.add_argument("--endtime", default=None)
+    p_sweep.add_argument("--tp-tol-s", type=float, default=1.5)
+    p_sweep.add_argument("--err-window-s", type=float, default=5.0)
+    p_sweep.set_defaults(func=sweep_pick_metrics)
+
+    p_filter = sub.add_parser("filter-snr-jsonl", help="Write a picker JSONL filtered by SNR.")
+    p_filter.add_argument("--picks-jsonl", type=Path, required=True)
+    p_filter.add_argument("--output-jsonl", type=Path, required=True)
+    p_filter.add_argument("--summary-json", type=Path, required=True)
+    p_filter.add_argument("--snr-threshold", type=float, required=True)
+    p_filter.add_argument("--starttime", default=None)
+    p_filter.add_argument("--endtime", default=None)
+    p_filter.set_defaults(func=filter_snr_jsonl)
+
+    return parser
+
+
+def main() -> None:
+    args = build_arg_parser().parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()