| |
| """ |
| Consolidate raw collector runs into the published LocalNet-Dynamics dataset. |
| |
| Reads every `localnet_*.csv` (and its `.json` run metadata) from the raw |
| directory, validates and merges them (malformed timestamps, duplicates, loss |
| percentages outside 0-100 and failed speed-test latency probes are handled), |
| adds time-of-day features, gap information, rule-based reference labels and |
| manual event annotations, and writes: |
| |
| dataset/localnet_dynamics.csv consolidated dataset |
| dataset/localnet_dynamics.parquet same content (needs pyarrow) |
| dataset/summary.json statistics, per-run thresholds, label counts |
| |
| It also refreshes the auto-generated statistics section of DATASET_CARD.md so |
| the documentation always matches the data. |
| |
| python build_dataset.py |
| python build_dataset.py --raw-dir dataset/raw --out-dir dataset --mad-k 5 |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| import sys |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| from collect_data import COLLECTOR_VERSION, CSV_FIELDS |
|
|
| ROOT = Path(__file__).resolve().parent.parent |
|
|
| STRING_COLUMNS = ["run_id", "host_label", "timestamp_utc", "timestamp_local", "link_type", |
| "gateway_ip", "dns_server", "target", "wifi_ssid", "wifi_phy", |
| "speedtest_server", "notes"] |
| INT_COLUMNS = ["sample_index", "epoch_s", "packets_sent", "packets_received", "http_status", |
| "wifi_signal_pct", "wifi_channel", "speedtest_server_id", "lan_retransmits"] |
|
|
| RUN_COLUMNS = ["collector_version", "collector_os", "interval_s", "rtt_resolution_ms"] |
| TIME_COLUMNS = ["date_local", "hour_local", "weekday_local", "is_weekend", "gap_before_s"] |
| LABEL_COLUMNS = ["label_outage", "label_packet_loss", "label_high_latency", |
| "label_high_jitter", "label_gateway_degraded", "label_anomaly"] |
| EVENT_COLUMNS = ["event_category", "event_description"] |
|
|
| |
| THRESHOLD_RULES = { |
| "rtt_avg_ms": (10.0, 0.5), |
| "jitter_ms": (5.0, 1.0), |
| "gateway_rtt_avg_ms": (5.0, 1.0), |
| } |
|
|
| STATS_COLUMNS = [ |
| "rtt_avg_ms", "rtt_min_ms", "rtt_max_ms", "jitter_ms", "packet_loss_pct", |
| "gateway_rtt_avg_ms", "gateway_packet_loss_pct", "tcp_connect_median_ms", |
| "dns_resolve_ms", "dns_recursive_ms", "http_ms", "wifi_signal_pct", "wifi_rssi_dbm", |
| "wifi_rx_mbps", "download_mbps", "upload_mbps", "speedtest_ping_ms", |
| "download_loaded_latency_ms", "upload_loaded_latency_ms", "lan_throughput_mbps", |
| ] |
|
|
| |
| |
| SPEEDTEST_PING_FAILED_MS = 600_000 |
|
|
| CARD_BEGIN = "<!-- BEGIN GENERATED STATISTICS -->" |
| CARD_END = "<!-- END GENERATED STATISTICS -->" |
|
|
|
|
| |
| |
| |
|
|
| def os_family(platform_string: str) -> str: |
| p = (platform_string or "").lower() |
| if p.startswith("windows"): |
| return "Windows" |
| if p.startswith("macos") or p.startswith("darwin"): |
| return "macOS" |
| if p.startswith("linux"): |
| return "Linux" |
| return platform_string.split("-")[0] if platform_string else "" |
|
|
|
|
| def load_run(csv_path: Path) -> tuple[pd.DataFrame, dict]: |
| dtypes = {c: "string" for c in STRING_COLUMNS} |
| df = pd.read_csv(csv_path, dtype=dtypes, keep_default_na=True, na_values=[""]) |
| for c in STRING_COLUMNS: |
| if c in df.columns: |
| df[c] = df[c].fillna("").astype(str) |
| meta: dict = {} |
| json_path = csv_path.with_suffix(".json") |
| if json_path.exists(): |
| try: |
| meta = json.loads(json_path.read_text(encoding="utf-8")) |
| except ValueError: |
| meta = {} |
| if "run_id" not in df.columns or df["run_id"].eq("").all(): |
| df["run_id"] = meta.get("run_id") or csv_path.stem.replace("localnet_", "") |
| df["collector_version"] = meta.get("collector_version", "") |
| df["collector_os"] = os_family((meta.get("environment") or {}).get("os", "")) |
| interval = meta.get("interval_s") |
| if interval is None and "epoch_s" in df.columns and len(df) > 1: |
| interval = float(np.nanmedian(np.diff(df["epoch_s"].astype(float).values))) |
| df["interval_s"] = interval |
| df["rtt_resolution_ms"] = (meta.get("environment") or {}).get("ping_resolution_ms") |
| return df, meta |
|
|
|
|
| def load_raw(raw_dir: Path) -> tuple[pd.DataFrame, dict[str, dict]]: |
| files = sorted(raw_dir.glob("localnet_*.csv")) |
| if not files: |
| raise SystemExit(f"no localnet_*.csv files found in {raw_dir}") |
| frames, metas = [], {} |
| for path in files: |
| df, meta = load_run(path) |
| if df.empty: |
| print(f"skipping empty file {path.name}") |
| continue |
| frames.append(df) |
| metas[str(df["run_id"].iloc[0])] = meta |
| print(f"loaded {path.name}: {len(df)} rows") |
| df = pd.concat(frames, ignore_index=True, sort=False) |
| for c in CSV_FIELDS: |
| if c not in df.columns: |
| df[c] = "" if c in STRING_COLUMNS else np.nan |
| return df, metas |
|
|
|
|
| |
| |
| |
|
|
| def validate(df: pd.DataFrame) -> pd.DataFrame: |
| before = len(df) |
| df = df[df["timestamp_utc"].str.match(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$")] |
| dropped = before - len(df) |
| if dropped: |
| print(f"dropped {dropped} rows with malformed timestamps") |
| df = df.drop_duplicates(subset=["run_id", "timestamp_utc"], keep="first") |
| df = df.sort_values(["run_id", "epoch_s"], kind="stable").reset_index(drop=True) |
| for col in ("packet_loss_pct", "gateway_packet_loss_pct"): |
| bad = (df[col] < 0) | (df[col] > 100) |
| if bad.any(): |
| print(f"warning: {int(bad.sum())} rows have {col} outside 0-100; set to missing") |
| df.loc[bad, col] = np.nan |
| failed = df["speedtest_ping_ms"] >= SPEEDTEST_PING_FAILED_MS |
| if failed.any(): |
| print(f"{int(failed.sum())} speed-test rows have a failed server latency probe " |
| f"(speedtest_ping_ms >= {SPEEDTEST_PING_FAILED_MS:,}); set to missing") |
| df.loc[failed, "speedtest_ping_ms"] = np.nan |
| return df |
|
|
|
|
| def add_time_features(df: pd.DataFrame) -> pd.DataFrame: |
| local = pd.to_datetime(df["timestamp_local"].str[:19], format="%Y-%m-%dT%H:%M:%S", errors="coerce") |
| df["date_local"] = local.dt.strftime("%Y-%m-%d") |
| df["hour_local"] = local.dt.hour |
| df["weekday_local"] = local.dt.dayofweek |
| df["is_weekend"] = (local.dt.dayofweek >= 5).astype(int) |
| df["gap_before_s"] = df.groupby("run_id")["epoch_s"].diff() |
| return df |
|
|
|
|
| def robust_threshold(values: pd.Series, floor_abs: float, floor_rel: float, k: float) -> dict: |
| v = values.dropna().astype(float) |
| if len(v) < 20: |
| return {"n": int(len(v)), "median": None, "mad": None, "threshold": None} |
| median = float(v.median()) |
| mad = float((v - median).abs().median()) |
| threshold = median + max(k * 1.4826 * mad, floor_abs, floor_rel * median) |
| return {"n": int(len(v)), "median": round(median, 3), "mad": round(mad, 3), |
| "threshold": round(threshold, 3)} |
|
|
|
|
| def add_labels(df: pd.DataFrame, k: float) -> tuple[pd.DataFrame, dict]: |
| thresholds: dict[str, dict] = {} |
| for col in LABEL_COLUMNS: |
| df[col] = 0 |
| sent = df["packets_sent"].fillna(0) |
| received = df["packets_received"].fillna(0) |
| outage = (sent > 0) & (received == 0) |
| df["label_outage"] = outage.astype(int) |
| df["label_packet_loss"] = (df["packet_loss_pct"].gt(0) & ~outage).astype(int) |
|
|
| for run_id, idx in df.groupby("run_id").groups.items(): |
| part = df.loc[idx] |
| rules = {col: robust_threshold(part[col], fa, fr, k) for col, (fa, fr) in THRESHOLD_RULES.items()} |
| thresholds[run_id] = rules |
| t = rules["rtt_avg_ms"]["threshold"] |
| if t is not None: |
| df.loc[idx, "label_high_latency"] = part["rtt_avg_ms"].gt(t).astype(int) |
| t = rules["jitter_ms"]["threshold"] |
| if t is not None: |
| df.loc[idx, "label_high_jitter"] = part["jitter_ms"].gt(t).astype(int) |
| t = rules["gateway_rtt_avg_ms"]["threshold"] |
| gw = part["gateway_packet_loss_pct"].gt(0) |
| if t is not None: |
| gw |= part["gateway_rtt_avg_ms"].gt(t) |
| df.loc[idx, "label_gateway_degraded"] = gw.astype(int) |
|
|
| df["label_anomaly"] = df[LABEL_COLUMNS[:-1]].max(axis=1).astype(int) |
| return df, thresholds |
|
|
|
|
| def load_events(path: Path) -> pd.DataFrame: |
| columns = ["start_utc", "end_utc", "category", "description"] |
| if not path.exists(): |
| return pd.DataFrame(columns=columns) |
| ev = pd.read_csv(path, dtype=str, keep_default_na=False) |
| missing = [c for c in columns if c not in ev.columns] |
| if missing: |
| raise SystemExit(f"{path}: missing columns {missing}") |
| ev["start"] = pd.to_datetime(ev["start_utc"], utc=True, errors="coerce") |
| ev["end"] = pd.to_datetime(ev["end_utc"], utc=True, errors="coerce") |
| bad = ev["start"].isna() | ev["end"].isna() |
| if bad.any(): |
| print(f"warning: ignoring {int(bad.sum())} events with unparsable timestamps") |
| ev = ev[~bad] |
| return ev.reset_index(drop=True) |
|
|
|
|
| def add_events(df: pd.DataFrame, events: pd.DataFrame) -> pd.DataFrame: |
| df["event_category"] = "" |
| df["event_description"] = "" |
| if events.empty: |
| return df |
| ts = pd.to_datetime(df["timestamp_utc"], utc=True) |
| cats = [[] for _ in range(len(df))] |
| descs = [[] for _ in range(len(df))] |
| for _, ev in events.iterrows(): |
| hit = np.flatnonzero((ts >= ev["start"]) & (ts <= ev["end"])) |
| for i in hit: |
| cats[i].append(str(ev["category"])) |
| descs[i].append(str(ev["description"])) |
| df["event_category"] = [" | ".join(c) for c in cats] |
| df["event_description"] = [" | ".join(d) for d in descs] |
| return df |
|
|
|
|
| def order_columns(df: pd.DataFrame) -> pd.DataFrame: |
| base = [c for c in CSV_FIELDS if c != "notes"] |
| head = base[:11] |
| body = base[11:] |
| ordered = head + RUN_COLUMNS + TIME_COLUMNS + body + LABEL_COLUMNS + EVENT_COLUMNS + ["notes"] |
| extra = [c for c in df.columns if c not in ordered] |
| return df[ordered + extra] |
|
|
|
|
| def cast_types(df: pd.DataFrame) -> pd.DataFrame: |
| for col in INT_COLUMNS + ["hour_local", "weekday_local", "is_weekend"] + LABEL_COLUMNS: |
| if col in df.columns: |
| df[col] = df[col].astype("Int64") |
| return df |
|
|
|
|
| |
| |
| |
|
|
| def column_summary(series: pd.Series) -> dict | None: |
| v = series.dropna().astype(float) |
| if v.empty: |
| return None |
| return {"count": int(v.size), "mean": round(float(v.mean()), 3), |
| "median": round(float(v.median()), 3), "p95": round(float(v.quantile(0.95)), 3), |
| "min": round(float(v.min()), 3), "max": round(float(v.max()), 3)} |
|
|
|
|
| def build_summary(df: pd.DataFrame, metas: dict, thresholds: dict, events: pd.DataFrame, |
| k: float) -> dict: |
| ts = pd.to_datetime(df["timestamp_utc"], utc=True) |
| runs = [] |
| expected_total = 0.0 |
| for run_id, part in df.groupby("run_id", sort=True): |
| meta = metas.get(run_id, {}) |
| interval = part["interval_s"].iloc[0] |
| span = float(part["epoch_s"].max() - part["epoch_s"].min()) |
| expected = span / float(interval) + 1 if interval and interval > 0 else len(part) |
| expected_total += expected |
| runs.append({ |
| "run_id": run_id, |
| "host_label": part["host_label"].iloc[0], |
| "rows": int(len(part)), |
| "first_utc": part["timestamp_utc"].iloc[0], |
| "last_utc": part["timestamp_utc"].iloc[-1], |
| "span_hours": round(span / 3600.0, 2), |
| "interval_s": float(interval) if interval else None, |
| "coverage_pct": round(100.0 * len(part) / expected, 2) if expected else None, |
| "link_types": {str(k_): int(v) for k_, v in part["link_type"].value_counts().items()}, |
| "collector_version": meta.get("collector_version", ""), |
| "os": (meta.get("environment") or {}).get("os", ""), |
| "status": meta.get("status", ""), |
| "thresholds": thresholds.get(run_id, {}), |
| }) |
| labels = {col: {"rows": int(df[col].sum()), "share_pct": round(100.0 * float(df[col].mean()), 3)} |
| for col in LABEL_COLUMNS} |
| return { |
| "generated_utc": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), |
| "builder_version": COLLECTOR_VERSION, |
| "rows": int(len(df)), |
| "columns": int(df.shape[1]), |
| "runs": runs, |
| "first_utc": ts.min().strftime("%Y-%m-%dT%H:%M:%SZ"), |
| "last_utc": ts.max().strftime("%Y-%m-%dT%H:%M:%SZ"), |
| "span_days": round((ts.max() - ts.min()).total_seconds() / 86400.0, 2), |
| "coverage_pct": round(100.0 * len(df) / expected_total, 2) if expected_total else None, |
| "label_rule": { |
| "mad_k": k, |
| "description": "threshold = median + max(k * 1.4826 * MAD, absolute floor, " |
| "relative floor * median), computed per run", |
| "floors": {c: {"absolute_ms": fa, "relative": fr} for c, (fa, fr) in THRESHOLD_RULES.items()}, |
| }, |
| "labels": labels, |
| "events": int(len(events)), |
| "metrics": {c: column_summary(df[c]) for c in STATS_COLUMNS if column_summary(df[c])}, |
| } |
|
|
|
|
| def size_category(n: int) -> str: |
| bounds = [(1_000, "n<1K"), (10_000, "1K<n<10K"), (100_000, "10K<n<100K"), |
| (1_000_000, "100K<n<1M"), (10_000_000, "1M<n<10M")] |
| for limit, label in bounds: |
| if n < limit: |
| return label |
| return "10M<n<100M" |
|
|
|
|
| def render_card_block(summary: dict) -> str: |
| lines = [CARD_BEGIN, |
| f"Generated by `scripts/build_dataset.py` on {summary['generated_utc']} " |
| f"from {len(summary['runs'])} collection run(s).", "", |
| "| Item | Value |", "|---|---|", |
| f"| Rows | {summary['rows']:,} |", |
| f"| Columns | {summary['columns']} |", |
| f"| First sample (UTC) | {summary['first_utc']} |", |
| f"| Last sample (UTC) | {summary['last_utc']} |", |
| f"| Span | {summary['span_days']} days |", |
| f"| Sampling coverage | {summary['coverage_pct']} % of the samples expected at the configured interval |", |
| f"| Manual event annotations | {summary['events']} |", ""] |
| lines += ["| Run | Vantage | Link | OS | Interval | Rows | Span | Coverage |", |
| "|---|---|---|---|---|---|---|---|"] |
| for r in summary["runs"]: |
| links = ", ".join(f"{k_} ({v})" for k_, v in r["link_types"].items()) |
| interval = f"{r['interval_s']:.0f} s" if r["interval_s"] else "-" |
| lines.append(f"| {r['run_id']} | {r['host_label'] or '-'} | {links} | {os_family(r['os']) or '-'} | " |
| f"{interval} | {r['rows']:,} | {r['span_hours']} h | {r['coverage_pct']} % |") |
| lines += ["", "| Metric | n | Median | Mean | p95 | Max |", "|---|---|---|---|---|---|"] |
| for col, st in summary["metrics"].items(): |
| lines.append(f"| {col} | {st['count']:,} | {st['median']} | {st['mean']} | {st['p95']} | {st['max']} |") |
| lines += ["", "| Reference label | Rows | Share |", "|---|---|---|"] |
| for col, st in summary["labels"].items(): |
| lines.append(f"| {col} | {st['rows']:,} | {st['share_pct']} % |") |
| lines += ["", CARD_END] |
| return "\n".join(lines) |
|
|
|
|
| def update_card(card_path: Path, summary: dict) -> None: |
| text = card_path.read_text(encoding="utf-8") |
| if CARD_BEGIN not in text or CARD_END not in text: |
| print(f"warning: {card_path.name} has no generated-statistics markers; not updated") |
| return |
| block = render_card_block(summary) |
| pattern = re.compile(re.escape(CARD_BEGIN) + r".*?" + re.escape(CARD_END), re.DOTALL) |
| text = pattern.sub(lambda _: block, text, count=1) |
| text = re.sub(r"(size_categories:\s*\n\s*-\s*)(\S+)", lambda m: m.group(1) + size_category(summary["rows"]), |
| text, count=1) |
| card_path.write_text(text, encoding="utf-8") |
| print(f"updated statistics in {card_path}") |
|
|
|
|
| |
| |
| |
|
|
| def main(argv: list[str] | None = None) -> int: |
| p = argparse.ArgumentParser(description="Build the consolidated LocalNet-Dynamics dataset.") |
| p.add_argument("--raw-dir", default=str(ROOT / "dataset" / "raw")) |
| p.add_argument("--out-dir", default=str(ROOT / "dataset")) |
| p.add_argument("--events", default=None, help="events CSV (default: <raw-dir>/events.csv)") |
| p.add_argument("--card", default=str(ROOT / "DATASET_CARD.md")) |
| p.add_argument("--no-card", action="store_true", help="do not touch the dataset card") |
| p.add_argument("--no-parquet", action="store_true") |
| p.add_argument("--mad-k", type=float, default=5.0, |
| help="MAD multiplier for the high-latency / high-jitter / gateway rules") |
| args = p.parse_args(argv) |
|
|
| raw_dir, out_dir = Path(args.raw_dir), Path(args.out_dir) |
| out_dir.mkdir(parents=True, exist_ok=True) |
| events_path = Path(args.events) if args.events else raw_dir / "events.csv" |
|
|
| df, metas = load_raw(raw_dir) |
| df = validate(df) |
| df = add_time_features(df) |
| df, thresholds = add_labels(df, args.mad_k) |
| events = load_events(events_path) |
| df = add_events(df, events) |
| df = cast_types(order_columns(df)) |
|
|
| csv_out = out_dir / "localnet_dynamics.csv" |
| df.to_csv(csv_out, index=False) |
| print(f"wrote {csv_out} ({len(df):,} rows, {df.shape[1]} columns)") |
| if not args.no_parquet: |
| try: |
| parquet_out = out_dir / "localnet_dynamics.parquet" |
| df.to_parquet(parquet_out, index=False) |
| print(f"wrote {parquet_out}") |
| except (ImportError, ValueError) as exc: |
| print(f"parquet not written ({exc}); install pyarrow to enable it") |
|
|
| summary = build_summary(df, metas, thresholds, events, args.mad_k) |
| (out_dir / "summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8") |
| print(f"wrote {out_dir / 'summary.json'}") |
| if not args.no_card and Path(args.card).exists(): |
| update_card(Path(args.card), summary) |
|
|
| print(f"\nrows: {summary['rows']:,} span: {summary['span_days']} days " |
| f"coverage: {summary['coverage_pct']} %") |
| for col, st in summary["labels"].items(): |
| print(f" {col:<24}{st['rows']:>8} ({st['share_pct']} %)") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
