| |
| """ |
| Render the LocalNet-Dynamics figures as PNG and PDF. |
| |
| Reads the consolidated dataset and dataset/analysis.json (written by |
| analyze.py) and writes every figure twice, figures/png/<name>.png and |
| figures/pdf/<name>.pdf, cropped to the drawn area with no margin: |
| |
| overview_timeline the whole capture: target RTT, TCP connect, first hop, loss |
| diurnal_profile hour-of-day latency, loss (weekday/weekend) and tail shares |
| calendar_heatmaps day-by-hour loss share, high-latency share, HTTP > 1 s share |
| degradation_anatomy a path change next to a first-hop event, probe by probe |
| tcp_vs_icmp the TCP/ICMP floor split that ping cannot see |
| loss_anatomy what a lost echo means for the other probes |
| regimes distributions before and after the change point |
| autocorrelation persistence of every metric up to a one-day lag |
| speedtest WAN throughput by time and by server |
| labels reference-label shares in the two regimes |
| |
| python plot_figures.py |
| python plot_figures.py --input dataset/localnet_dynamics.parquet --out-dir figures |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| from analyze import ROOT, analyse, load |
|
|
| BLUE, ORANGE, AQUA, YELLOW = "#2a78d6", "#eb6834", "#1baf7a", "#eda100" |
| MAGENTA, GREEN, VIOLET, RED = "#e87ba4", "#008300", "#6250d6", "#e34948" |
| INK, INK2, MUTED, GRID, AXIS = "#0b0b0b", "#52514e", "#898781", "#e1e0d9", "#c3c2b7" |
| BLUES = ["#f3f7fd", "#cde2fb", "#9ec5f4", "#6da7ec", "#3987e5", "#256abf", "#184f95", "#0d366b"] |
| NAVY = "#0d366b" |
| LOSS_CLASSES = [("no_loss", "no loss"), ("one_lost", "1 of 10 lost"), ("two_plus_lost", "2+ of 10 lost")] |
| WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] |
|
|
|
|
| def style(plt) -> None: |
| plt.rcParams.update({ |
| "figure.facecolor": "white", "axes.facecolor": "white", "savefig.facecolor": "white", |
| "font.family": "sans-serif", |
| "font.sans-serif": ["Inter", "Segoe UI", "Helvetica Neue", "Arial", "DejaVu Sans"], |
| "font.size": 15, "axes.titlesize": 18, "axes.titleweight": "semibold", "axes.titlepad": 14, |
| "axes.labelsize": 15, "axes.labelcolor": INK2, "xtick.labelsize": 13, "ytick.labelsize": 13, |
| "xtick.color": INK2, "ytick.color": INK2, "legend.fontsize": 13, "legend.frameon": False, |
| "axes.edgecolor": AXIS, "axes.linewidth": 1.0, "axes.grid": True, "grid.color": GRID, |
| "grid.linewidth": 0.8, "axes.axisbelow": True, "axes.spines.top": False, "axes.spines.right": False, |
| "lines.linewidth": 2.0, "xtick.major.size": 0, "ytick.major.size": 0, |
| "xtick.major.pad": 8, "ytick.major.pad": 8, "legend.handlelength": 1.6, |
| }) |
|
|
|
|
| def save(fig, out: Path, name: str) -> None: |
| (out / "png").mkdir(parents=True, exist_ok=True) |
| (out / "pdf").mkdir(parents=True, exist_ok=True) |
| fig.savefig(out / "png" / f"{name}.png", dpi=200, bbox_inches="tight", pad_inches=0) |
| fig.savefig(out / "pdf" / f"{name}.pdf", bbox_inches="tight", pad_inches=0, |
| metadata={"CreationDate": None, "ModDate": None}) |
|
|
|
|
| def month_day(ts) -> str: |
| return f"{ts:%b %-d}" if sys.platform != "win32" else f"{ts:%b %d}".replace(" 0", " ") |
|
|
|
|
| def period_label(g: dict, key: str) -> str: |
| first, last = pd.Timestamp(g[key]["first_date"]), pd.Timestamp(g[key]["last_date"]) |
| return f"{month_day(first)} to {month_day(last)}" |
|
|
|
|
| def date_axis(ax, mdates) -> None: |
| ax.xaxis.set_major_locator(mdates.DayLocator(interval=2)) |
| ax.xaxis.set_major_formatter(mdates.DateFormatter("%b %d")) |
| ax.xaxis.set_minor_locator(mdates.DayLocator()) |
| for label in ax.get_xticklabels(): |
| label.set_rotation(0) |
|
|
|
|
| def shade_episodes(ax, a: dict, labels: bool = False) -> list: |
| handles = [] |
| kinds = {"path change": (BLUE, 0.14, "path change (latency floor moved)"), |
| "first hop": (AQUA, 0.22, "first-hop degradation"), |
| "queueing": (YELLOW, 0.22, "queueing")} |
| seen = set() |
| for e in a["latency_episodes"]: |
| color, alpha, text = kinds[e["kind"]] |
| s, t = pd.Timestamp(e["start_local"][:19]), pd.Timestamp(e["end_local"][:19]) |
| ax.axvspan(s, t, color=color, alpha=alpha, linewidth=0, zorder=0) |
| if e["kind"] not in seen: |
| seen.add(e["kind"]) |
| handles.append((color, alpha, text)) |
| for o in a["outages"]: |
| ax.axvline(pd.Timestamp(o["start_local"][:19]), color=RED, linewidth=2.2, alpha=0.9, zorder=1) |
| split = pd.Timestamp(a["regimes"]["split_date"]) |
| ax.axvline(split, color=INK2, linewidth=1.6, linestyle=(0, (5, 4)), zorder=1) |
| return handles |
|
|
|
|
| |
| |
| |
|
|
| def fig_overview(df, a, out, plt, mdates): |
| from matplotlib.lines import Line2D |
| from matplotlib.patches import Patch |
| x = df["ts_local"] |
| fig, axes = plt.subplots(4, 1, figsize=(18, 13), sharex=True, |
| gridspec_kw={"height_ratios": [3, 2.2, 1.6, 1.6], "hspace": 0.32}) |
| rtt_cap = 40 |
| ax = axes[0] |
| handles = shade_episodes(ax, a) |
| ax.plot(x, df["rtt_avg_ms"].clip(upper=rtt_cap), color=BLUE, linewidth=0.5, alpha=0.45) |
| roll = df["rtt_avg_ms"].rolling(60, center=True, min_periods=20).median() |
| ax.plot(x, roll, color=NAVY, linewidth=1.8) |
| ax.set_ylim(0, rtt_cap) |
| ax.set_ylabel("ms") |
| ax.set_title(f"Round-trip time to {df['target'].iloc[0]} (ICMP, 10-echo mean per sample, clipped at {rtt_cap} ms)", |
| loc="left") |
| series = [Line2D([], [], color=BLUE, linewidth=1.2, alpha=0.7, label="per sample"), |
| Line2D([], [], color=NAVY, linewidth=2.2, label="30-minute rolling median")] |
| bands = [Patch(facecolor=c, alpha=min(1.0, al * 2.2), label=t) for c, al, t in handles] |
| bands += [Line2D([], [], color=RED, linewidth=2.2, label="outage (gateway unreachable)"), |
| Line2D([], [], color=INK2, linewidth=1.6, linestyle=(0, (5, 4)), label="change point in daily loss share")] |
| fig.legend(handles=series + bands, loc="lower center", bbox_to_anchor=(0.5, 0.925), ncol=6, |
| frameon=False, columnspacing=1.6, handletextpad=0.6) |
|
|
| ax = axes[1] |
| shade_episodes(ax, a) |
| ax.scatter(x, df["tcp_connect_min_ms"].clip(upper=rtt_cap), s=2.5, color=ORANGE, alpha=0.35, linewidth=0, rasterized=True) |
| ax.set_ylim(0, rtt_cap) |
| ax.set_ylabel("ms") |
| ax.set_title("Fastest of 5 TCP handshakes to port 443 of the same host (sub-millisecond resolution)", loc="left") |
|
|
| ax = axes[2] |
| shade_episodes(ax, a) |
| ax.plot(x, df["gateway_rtt_avg_ms"].clip(upper=20), color=AQUA, linewidth=0.7) |
| ax.set_ylim(0, 20) |
| ax.set_ylabel("ms") |
| ax.set_title("Round-trip time to the default gateway (first hop, clipped at 20 ms)", loc="left") |
|
|
| ax = axes[3] |
| shade_episodes(ax, a) |
| hourly = (df["packet_loss_pct"] > 0).groupby(df["ts_local"].dt.floor("h")).mean() * 100 |
| ax.bar(hourly.index, hourly.values, width=pd.Timedelta(hours=1), color=RED, linewidth=0, alpha=0.9) |
| ax.set_ylim(0, 100) |
| ax.set_ylabel("% of samples") |
| ax.set_title("Samples with at least one lost echo, per hour", loc="left") |
| ax.set_xlabel("local time (America/New_York)") |
| date_axis(ax, mdates) |
| ax.set_xlim(x.min() - pd.Timedelta(hours=3), x.max() + pd.Timedelta(hours=3)) |
| save(fig, out, "overview_timeline") |
| plt.close(fig) |
|
|
|
|
| def fig_diurnal(df, a, out, plt): |
| prof = pd.DataFrame(a["hour_profile"]).set_index("hour").reindex(range(24)) |
| hours = np.arange(24) |
| fig, axes = plt.subplots(1, 3, figsize=(20, 6.4), gridspec_kw={"wspace": 0.28}) |
| ax = axes[0] |
| ax.fill_between(hours, prof["rtt_p25"], prof["rtt_p75"], color=BLUE, alpha=0.16, linewidth=0, label="interquartile range") |
| ax.plot(hours, prof["rtt_median"], color=BLUE, marker="o", markersize=6, label="median") |
| ax.plot(hours, prof["rtt_p95"], color=NAVY, marker="o", markersize=6, label="95th percentile") |
| ax.set_ylim(0, max(32, float(prof["rtt_p95"].max()) * 1.15)) |
| ax.set_ylabel("target RTT (ms)") |
| ax.set_title("Latency by local hour", loc="left") |
| ax.legend(loc="upper center", ncol=1) |
| ax = axes[1] |
| ax.plot(hours, prof["loss_share_weekday_pct"], color=BLUE, marker="o", markersize=6, label="weekdays") |
| ax.plot(hours, prof["loss_share_weekend_pct"], color=ORANGE, marker="o", markersize=6, label="weekends") |
| ax.set_ylim(0, max(30, float(prof[["loss_share_weekday_pct", "loss_share_weekend_pct"]].max().max()) * 1.2)) |
| ax.set_ylabel("% of samples with a lost echo") |
| ax.set_title("Loss by local hour", loc="left") |
| ax.legend(loc="upper left") |
| ax = axes[2] |
| ax.plot(hours, prof["http_over_1s_pct"], color=VIOLET, marker="o", markersize=6, label="HTTP response > 1 s") |
| ax.plot(hours, prof["high_latency_pct"], color=BLUE, marker="o", markersize=6, label="high-latency label") |
| ax.set_ylim(0, max(25, float(prof[["http_over_1s_pct", "high_latency_pct"]].max().max()) * 1.25)) |
| ax.set_ylabel("% of samples") |
| ax.set_title("Two tails with opposite clocks", loc="left") |
| ax.legend(loc="upper center") |
| for ax in axes: |
| ax.set_xticks(range(0, 24, 3)) |
| ax.set_xticklabels([f"{h:02d}" for h in range(0, 24, 3)]) |
| ax.set_xlim(-0.5, 23.5) |
| ax.set_xlabel("local hour") |
| save(fig, out, "diurnal_profile") |
| plt.close(fig) |
|
|
|
|
| def fig_heatmaps(df, a, out, plt): |
| from matplotlib.colors import LinearSegmentedColormap |
| cmap = LinearSegmentedColormap.from_list("blues", BLUES).with_extremes(bad="#eeede9") |
| panels = [ |
| ("packet_loss_pct", lambda s: 100 * (s > 0).mean(), "Samples with a lost echo (%)"), |
| ("label_high_latency", lambda s: 100 * s.mean(), "Samples over the high-latency threshold (%)"), |
| ("http_ms", lambda s: 100 * (s.dropna() > 1000).mean(), "HTTP responses slower than 1 s (%)"), |
| ] |
| dates = sorted(df["date_local"].unique()) |
| weekday = df.groupby("date_local")["weekday_local"].first() |
| fig, axes = plt.subplots(1, 3, figsize=(22, 0.42 * len(dates) + 2.4), gridspec_kw={"wspace": 0.12}) |
| for ax, (col, fn, title) in zip(axes, panels): |
| pivot = df.pivot_table(index="date_local", columns="hour_local", values=col, aggfunc=fn) |
| pivot = pivot.reindex(index=dates, columns=range(24)) |
| vmax = max(1.0, float(np.nanpercentile(pivot.values, 98))) |
| im = ax.imshow(np.ma.masked_invalid(pivot.values.astype(float)), aspect="auto", cmap=cmap, |
| vmin=0, vmax=vmax, interpolation="nearest") |
| ax.set_xticks(range(0, 24, 3)) |
| ax.set_xticklabels([f"{h:02d}" for h in range(0, 24, 3)]) |
| ax.set_xlabel("local hour") |
| ax.set_title(title, loc="left") |
| ax.grid(False) |
| for spine in ax.spines.values(): |
| spine.set_visible(False) |
| cbar = fig.colorbar(im, ax=ax, orientation="horizontal", fraction=0.045, pad=0.14, aspect=28) |
| cbar.outline.set_visible(False) |
| cbar.ax.tick_params(labelsize=12) |
| axes[0].set_yticks(range(len(dates))) |
| axes[0].set_yticklabels([f"{WEEKDAYS[int(weekday[d])]} {pd.Timestamp(d):%b %d}" for d in dates]) |
| for d, label in zip(dates, axes[0].get_yticklabels()): |
| if int(weekday[d]) >= 5: |
| label.set_color(ORANGE) |
| label.set_fontweight("semibold") |
| for ax in axes[1:]: |
| ax.set_yticks([]) |
| save(fig, out, "calendar_heatmaps") |
| plt.close(fig) |
|
|
|
|
| def fig_anatomy(df, a, out, plt, mdates): |
| def window(kind): |
| """The longest episode of this kind, extended over same-kind episodes within two hours of it.""" |
| eps = [e for e in a["latency_episodes"] if e["kind"] == kind] |
| if not eps: |
| return None |
| chain = [max(eps, key=lambda e: e["hours"])] |
| grown = True |
| while grown: |
| grown = False |
| lo = min(pd.Timestamp(e["start_local"][:19]) for e in chain) - pd.Timedelta(hours=2) |
| hi = max(pd.Timestamp(e["end_local"][:19]) for e in chain) + pd.Timedelta(hours=2) |
| for e in eps: |
| if e not in chain and lo <= pd.Timestamp(e["start_local"][:19]) <= hi: |
| chain.append(e) |
| grown = True |
| return sorted(chain, key=lambda e: e["start_local"]) |
|
|
| chosen = [(window("path change"), "Path change"), (window("first hop"), "First-hop event")] |
| chosen = [(c, t) for c, t in chosen if c] |
| if not chosen: |
| return |
| fig, axes = plt.subplots(2, len(chosen), figsize=(10 * len(chosen), 9.5), sharex="col", |
| gridspec_kw={"height_ratios": [2.4, 1], "hspace": 0.22, "wspace": 0.16}, squeeze=False) |
| cap, top = 45, 60 |
| for col, (chain, title) in enumerate(chosen): |
| start = pd.Timestamp(chain[0]["start_local"][:19]) |
| end = pd.Timestamp(chain[-1]["end_local"][:19]) |
| part = df[(df["ts_local"] >= start - pd.Timedelta(hours=2)) & (df["ts_local"] <= end + pd.Timedelta(hours=2))] |
| x = part["ts_local"] |
| tint = BLUE if chain[0]["kind"] == "path change" else AQUA |
| ax = axes[0, col] |
| for e in chain: |
| ax.axvspan(pd.Timestamp(e["start_local"][:19]), pd.Timestamp(e["end_local"][:19]), color=tint, alpha=0.12, linewidth=0) |
| ax.plot(x, part["rtt_avg_ms"].clip(upper=cap), color=BLUE, linewidth=1.0, alpha=0.5, label="ICMP mean of 10") |
| ax.plot(x, part["rtt_min_ms"].clip(upper=cap), color=NAVY, linewidth=1.4, label="ICMP minimum of 10") |
| ax.plot(x, part["tcp_connect_min_ms"].clip(upper=cap), color=ORANGE, linewidth=1.2, alpha=0.9, label="TCP fastest of 5") |
| ax.set_ylim(0, top) |
| ax.set_ylabel(f"ms to target (clipped at {cap})") |
| hours = (end - start).total_seconds() / 3600.0 |
| ax.set_title(f"{title}: {WEEKDAYS[chain[0]['weekday']]} {month_day(start)}, {hours:.1f} h", loc="left") |
| ax.legend(loc="upper left", ncol=3) |
| ax = axes[1, col] |
| for e in chain: |
| ax.axvspan(pd.Timestamp(e["start_local"][:19]), pd.Timestamp(e["end_local"][:19]), color=tint, alpha=0.12, linewidth=0) |
| ax.plot(x, part["gateway_rtt_avg_ms"].clip(upper=30), color=AQUA, linewidth=1.2) |
| ax.set_ylim(0, 30) |
| ax.set_ylabel("ms to gateway") |
| ax.set_xlabel("local time") |
| ax.xaxis.set_major_locator(mdates.HourLocator(interval=2)) |
| ax.xaxis.set_major_formatter(mdates.DateFormatter("%H:%M")) |
| save(fig, out, "degradation_anatomy") |
| plt.close(fig) |
|
|
|
|
| def fig_tcp_icmp(df, a, out, plt, mdates): |
| split = pd.Timestamp(a["tcp_icmp"]["split_local"]) |
| fig, axes = plt.subplots(1, 2, figsize=(20, 6.4), gridspec_kw={"width_ratios": [2.3, 1], "wspace": 0.2}) |
| ax = axes[0] |
| x = df["ts_local"] |
| cap = 35 |
| from matplotlib.lines import Line2D |
| ax.scatter(x, df["tcp_connect_min_ms"].clip(upper=cap), s=2.5, color=ORANGE, alpha=0.35, linewidth=0, rasterized=True) |
| roll = df["rtt_min_ms"].rolling(120, center=True, min_periods=30).median() |
| ax.plot(x, roll, color=NAVY, linewidth=2.0) |
| handles = [Line2D([], [], marker="o", color=ORANGE, linestyle="none", markersize=8, label="TCP fastest of 5 handshakes, per sample"), |
| Line2D([], [], color=NAVY, linewidth=2.2, label="ICMP minimum of 10, 1-hour rolling median")] |
| ax.axvline(split, color=INK2, linewidth=1.6, linestyle=(0, (5, 4))) |
| ax.text(split, cap * 0.97, f" {month_day(split)} {split:%H:%M}", color=INK2, va="top", ha="left", fontsize=13) |
| ax.set_ylim(0, cap) |
| ax.set_ylabel("ms") |
| ax.set_xlabel("local time") |
| ax.set_title("Latency floor seen by TCP and by ICMP", loc="left") |
| ax.legend(handles=handles, loc="lower left") |
| date_axis(ax, mdates) |
| ax = axes[1] |
| before = df.loc[df["ts_local"] < split, "tcp_connect_min_ms"].dropna() |
| after = df.loc[df["ts_local"] >= split, "tcp_connect_min_ms"].dropna() |
| bins = np.arange(8, 32.5, 0.5) |
| ax.hist(before.clip(8, 32), bins=bins, density=True, color=MUTED, alpha=0.75, linewidth=0, |
| label=f"before ({len(before):,} samples)") |
| ax.hist(after.clip(8, 32), bins=bins, density=True, color=ORANGE, alpha=0.8, linewidth=0, |
| label=f"after ({len(after):,} samples)") |
| ax.set_xlabel("TCP fastest handshake (ms)") |
| ax.set_ylabel("density") |
| ax.set_title("Before and after the split", loc="left") |
| ax.legend(loc="upper right") |
| save(fig, out, "tcp_vs_icmp") |
| plt.close(fig) |
|
|
|
|
| def fig_loss(df, a, out, plt): |
| L = a["loss"] |
| fig = plt.figure(figsize=(20, 11)) |
| gs = fig.add_gridspec(2, 3, height_ratios=[1, 1.1], hspace=0.45, wspace=0.3) |
| ax = fig.add_subplot(gs[0, 0]) |
| counts = {int(k): v for k, v in L["packets_received_counts"].items()} |
| keys = sorted(counts, reverse=True) |
| ax.bar(range(len(keys)), [counts[k] for k in keys], color=BLUE, linewidth=0, width=0.72) |
| ax.set_xticks(range(len(keys))) |
| ax.set_xticklabels([str(k) for k in keys]) |
| ax.set_yscale("log") |
| ax.set_ylim(1, max(counts.values()) * 4) |
| ax.set_xlabel("echo replies received out of 10") |
| ax.set_ylabel("samples (log scale)") |
| ax.set_title("Loss comes one echo at a time", loc="left") |
| for i, k in enumerate(keys): |
| ax.text(i, counts[k] * 1.25, f"{counts[k]:,}", ha="center", va="bottom", fontsize=12, color=INK2) |
|
|
| xs = np.arange(len(LOSS_CLASSES)) |
| w = 0.36 |
| c = L["conditional"] |
|
|
| def grouped(ax, left, right, unit, title): |
| for offset, (key, color, name) in zip((-w / 2, w / 2), (left, right)): |
| values = [c[k][key] or 0.0 for k, _ in LOSS_CLASSES] |
| ax.bar(xs + offset, values, w, color=color, linewidth=0, label=name) |
| for i, v in enumerate(values): |
| ax.text(i + offset, v + 0.02 * top, f"{v:.1f}", ha="center", fontsize=12, color=INK2) |
| ax.set_xticks(xs) |
| ax.set_xticklabels([t for _, t in LOSS_CLASSES]) |
| ax.set_ylabel(unit) |
| ax.set_ylim(0, top) |
| ax.set_title(title, loc="left") |
| ax.legend(loc="upper left") |
|
|
| top = max(1.0, max((c[k]["http_over_1s_pct"] or 0.0) for k, _ in LOSS_CLASSES) * 1.35) |
| grouped(fig.add_subplot(gs[0, 1]), ("http_over_1s_pct", VIOLET, "HTTP response > 1 s"), |
| ("dns_recursive_over_200ms_pct", GREEN, "recursive DNS > 200 ms"), "% of samples", |
| "Application tails grow with ICMP loss") |
| top = max(1.0, max((c[k]["tcp_median"] or 0.0) for k, _ in LOSS_CLASSES) * 1.4) |
| grouped(fig.add_subplot(gs[0, 2]), ("jitter_median", MAGENTA, "jitter, median"), |
| ("tcp_median", ORANGE, "TCP handshake, median"), "ms", "Jitter rises, the TCP handshake does not") |
|
|
| ax = fig.add_subplot(gs[1, :]) |
| h = df["http_ms"].dropna() |
| lo, hi = 20, 8000 |
| bins = np.logspace(np.log10(lo), np.log10(hi), 150) |
| ax.hist(h.clip(lo, hi), bins=bins, color=VIOLET, linewidth=0) |
| ax.set_xscale("log") |
| ax.set_yscale("log") |
| ax.set_xlim(lo, hi) |
| ticks = [20, 50, 100, 200, 500, 1000, 2000, 5000] |
| ax.set_xticks(ticks) |
| ax.set_xticklabels([f"{t:,}" for t in ticks]) |
| ax.set_xlabel("HTTP time to response headers (ms, log scale)") |
| ax.set_ylabel("samples (log scale)") |
| H = a["dns_http"]["http"] |
| ax.set_title(f"HTTP response time: a smooth body around {H['median']:.0f} ms, then discrete modes near " |
| "1.1 s, 1.3 s and 4.1 s where lost packets wait for retransmission timers", loc="left") |
| ax.axvspan(1000, 1400, color=VIOLET, alpha=0.1, linewidth=0) |
| ax.axvspan(3900, 4400, color=VIOLET, alpha=0.1, linewidth=0) |
| save(fig, out, "loss_anatomy") |
| plt.close(fig) |
|
|
|
|
| def fig_regimes(df, a, out, plt): |
| g = a["regimes"] |
| split = g["split_date"] |
| before, after = df[df["date_local"] < split], df[df["date_local"] >= split] |
| panels = [("rtt_avg_ms", "ICMP round-trip time, mean of 10 (ms)", (8, 60), [10, 15, 20, 30, 40, 60]), |
| ("jitter_ms", "ICMP jitter (ms)", (0.1, 30), [0.1, 0.3, 1, 3, 10, 30]), |
| ("tcp_connect_median_ms", "TCP handshake, median of 5 (ms)", (10, 80), [10, 15, 20, 30, 40, 60, 80]), |
| ("dns_resolve_ms", "DNS, resolver-cached name (ms)", (5, 300), [5, 10, 20, 50, 100, 200, 300]), |
| ("dns_recursive_ms", "DNS, recursive lookup (ms)", (20, 2000), [20, 50, 100, 200, 500, 1000, 2000]), |
| ("http_ms", "HTTP time to response headers (ms)", (30, 5000), [30, 100, 300, 1000, 3000])] |
| fig, axes = plt.subplots(2, 3, figsize=(20, 10), gridspec_kw={"hspace": 0.5, "wspace": 0.18}) |
| for i, (ax, (col, title, lim, ticks)) in enumerate(zip(axes.ravel(), panels)): |
| for part, color, key in ((before, BLUE, "before"), (after, ORANGE, "after")): |
| v = np.sort(part[col].dropna().values) |
| if v.size == 0: |
| continue |
| v = np.clip(v, lim[0], lim[1]) |
| ax.step(v, np.arange(1, v.size + 1) / v.size * 100, where="post", color=color, linewidth=2.2, |
| label=f"{key}: {period_label(g, key)}") |
| ax.set_xscale("log") |
| ax.set_xlim(*lim) |
| ax.set_xticks(ticks) |
| ax.set_xticklabels([f"{t:g}" for t in ticks]) |
| ax.xaxis.set_minor_locator(plt.NullLocator()) |
| ax.set_ylim(0, 100) |
| ax.set_yticks([0, 25, 50, 75, 100]) |
| if i % 3 == 0: |
| ax.set_ylabel("% of samples at or below") |
| ax.set_title(title, loc="left") |
| axes[0, 0].legend(loc="lower right") |
| save(fig, out, "regimes") |
| plt.close(fig) |
|
|
|
|
| def fig_acf(df, a, out, plt): |
| A = a["autocorrelation"] |
| lags = A["lag_minutes"] |
| series = [("log_rtt_avg_ms", "ICMP RTT (log)", BLUE), ("jitter_ms", "jitter", MAGENTA), |
| ("loss_indicator", "lost echo (0/1)", RED), ("tcp_connect_min_ms", "TCP fastest handshake", ORANGE), |
| ("dns_recursive_ms", "recursive DNS", GREEN), ("http_ms", "HTTP", VIOLET)] |
| fig, ax = plt.subplots(figsize=(16, 7)) |
| for key, name, color in series: |
| pts = [(l, v) for l, v in zip(lags, A["values"][key]) if v is not None] |
| if pts: |
| ax.plot([l for l, _ in pts], [v for _, v in pts], color=color, marker="o", markersize=6, label=name) |
| ax.set_xscale("log") |
| ticks = [0.5, 1, 2.5, 5, 10, 30, 60, 180, 360, 720, 1440] |
| ax.set_xticks(ticks) |
| ax.set_xticklabels(["30 s", "1 m", "2.5 m", "5 m", "10 m", "30 m", "1 h", "3 h", "6 h", "12 h", "24 h"]) |
| ax.set_xlim(0.4, 1440 * 1.3) |
| ax.set_ylim(-0.05, 1.0) |
| ax.axhline(0, color=AXIS, linewidth=1.0) |
| ax.set_xlabel("lag") |
| ax.set_ylabel("autocorrelation") |
| ax.set_title("How long the network remembers: autocorrelation of each probe against lag", loc="left") |
| ax.legend(loc="upper right", ncol=2) |
| save(fig, out, "autocorrelation") |
| plt.close(fig) |
|
|
|
|
| def fig_speedtest(df, a, out, plt, mdates): |
| sp = df[df["download_mbps"].notna()].copy() |
| if sp.empty: |
| return |
| S = a["speedtest"] |
| failed = sp["speedtest_ping_ms"].isna() | (sp["speedtest_ping_ms"] >= 600_000) |
| fig = plt.figure(figsize=(20, 9.5)) |
| gs = fig.add_gridspec(2, 2, width_ratios=[1.45, 1], hspace=0.42, wspace=0.12) |
| for row, (col, color, title) in enumerate((("download_mbps", BLUE, "Download"), ("upload_mbps", ORANGE, "Upload"))): |
| ax = fig.add_subplot(gs[row, 0]) |
| ok, bad = sp[~failed], sp[failed] |
| ax.scatter(ok["ts_local"], ok[col], s=30, color=color, alpha=0.85, linewidth=0, label="server latency probe succeeded") |
| ax.scatter(bad["ts_local"], bad[col], s=42, facecolor="white", edgecolor=color, linewidth=1.4, |
| label="server latency probe failed") |
| ax.set_ylabel("Mbit/s") |
| ax.set_title(f"{title}: {len(sp)} hourly tests on {S['servers']} different servers" if row == 0 else title, loc="left") |
| ax.set_ylim(0, float(sp[col].max()) * 1.12) |
| if row == 0: |
| ax.legend(loc="upper left", ncol=2) |
| else: |
| ax.set_xlabel("local time") |
| date_axis(ax, mdates) |
| ax = fig.add_subplot(gs[:, 1]) |
| top = S["top_servers"] |
| names = [t["server"] for t in top] |
| for i, t in enumerate(top): |
| part = sp[sp["speedtest_server"] == t["server"]] |
| y = np.full(len(part), i) + np.random.default_rng(i).uniform(-0.18, 0.18, len(part)) |
| ax.scatter(part["download_mbps"], y, s=34, color=BLUE, alpha=0.6, linewidth=0) |
| ax.plot([t["download_median"], t["download_median"]], [i - 0.32, i + 0.32], color=NAVY, linewidth=3) |
| ax.set_yticks(range(len(top))) |
| ax.set_yticklabels([f"{n} ({t['n']})" for n, t in zip(names, top)]) |
| ax.yaxis.tick_right() |
| ax.invert_yaxis() |
| ax.set_xlabel("download (Mbit/s); bar = median of that server") |
| ax.set_title("Download depends on which server was picked", loc="left") |
| save(fig, out, "speedtest") |
| plt.close(fig) |
|
|
|
|
| def fig_labels(df, a, out, plt): |
| g = a["regimes"] |
| names = [("label_outage", "outage"), ("label_packet_loss", "packet loss"), ("label_high_latency", "high latency"), |
| ("label_high_jitter", "high jitter"), ("label_gateway_degraded", "gateway degraded"), ("label_anomaly", "any (anomaly)")] |
| ys = np.arange(len(names)) |
| h = 0.38 |
| fig, ax = plt.subplots(figsize=(14, 6.6)) |
| b = [g["before"]["labels_pct"][k] for k, _ in names] |
| c = [g["after"]["labels_pct"][k] for k, _ in names] |
| ax.barh(ys - h / 2, b, h, color=BLUE, linewidth=0, label=period_label(g, "before")) |
| ax.barh(ys + h / 2, c, h, color=ORANGE, linewidth=0, label=period_label(g, "after")) |
| for y, v in zip(ys - h / 2, b): |
| ax.text(v + 0.6, y, f"{v:.1f} %", va="center", fontsize=13, color=INK2) |
| for y, v in zip(ys + h / 2, c): |
| ax.text(v + 0.6, y, f"{v:.1f} %", va="center", fontsize=13, color=INK2) |
| ax.set_yticks(ys) |
| ax.set_yticklabels([n for _, n in names]) |
| ax.invert_yaxis() |
| ax.set_xlim(0, max(b + c) * 1.18) |
| ax.set_xlabel("% of samples carrying the label") |
| ax.set_title("Reference labels before and after the change point", loc="left") |
| ax.legend(loc="upper right") |
| save(fig, out, "labels") |
| plt.close(fig) |
|
|
|
|
| |
| |
| |
|
|
| def render_all(df: pd.DataFrame, a: dict, out: Path) -> list[str]: |
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.dates as mdates |
| import matplotlib.pyplot as plt |
| style(plt) |
| out.mkdir(parents=True, exist_ok=True) |
| fig_overview(df, a, out, plt, mdates) |
| fig_diurnal(df, a, out, plt) |
| fig_heatmaps(df, a, out, plt) |
| fig_anatomy(df, a, out, plt, mdates) |
| fig_tcp_icmp(df, a, out, plt, mdates) |
| fig_loss(df, a, out, plt) |
| fig_regimes(df, a, out, plt) |
| fig_acf(df, a, out, plt) |
| fig_speedtest(df, a, out, plt, mdates) |
| fig_labels(df, a, out, plt) |
| return sorted(p.name for p in (out / "png").glob("*.png")) |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| p = argparse.ArgumentParser(description="Render the dataset figures as PNG and PDF.") |
| p.add_argument("--input", default=None, |
| help="consolidated parquet or CSV (default: dataset/localnet_dynamics.parquet)") |
| p.add_argument("--analysis", default=None, |
| help="analysis JSON from analyze.py (default: next to the input; recomputed if missing)") |
| p.add_argument("--out-dir", default=str(ROOT / "figures")) |
| args = p.parse_args(argv) |
|
|
| path = Path(args.input) if args.input else ROOT / "dataset" / "localnet_dynamics.parquet" |
| if not path.exists() and not args.input: |
| path = ROOT / "dataset" / "localnet_dynamics.csv" |
| if not path.exists(): |
| raise SystemExit(f"{path} not found; run build_dataset.py first") |
| df = load(path) |
| analysis_path = Path(args.analysis) if args.analysis else path.parent / "analysis.json" |
| if analysis_path.exists(): |
| a = json.loads(analysis_path.read_text(encoding="utf-8")) |
| else: |
| summary_path = path.parent / "summary.json" |
| summary = json.loads(summary_path.read_text(encoding="utf-8")) if summary_path.exists() else None |
| a = analyse(df, summary) |
| names = render_all(df, a, Path(args.out_dir)) |
| print(f"{len(names)} figures written to {args.out_dir} (png/ and pdf/): " + ", ".join(names)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
