| """Walk through one episode with the ``Dataset`` API and check it against the physics.
|
|
|
| python examples/inspect_episode.py # episode 0 of data/
|
| python examples/inspect_episode.py --data data_small --episode 7 --step 500 --router potential
|
|
|
| Prints the design cell, the graph, the flows, the event timeline and the router summary; then,
|
| at one step, the capacities in force, the busiest buffers and links; recomputes the potential
|
| field of the tracked flows from the graph state and queue depths and compares it with the stored
|
| snapshot; and follows the steepest-current descent of a tracked flow from its source to its sink.
|
| Every comparison is asserted, so the script is also a test of the relational tables.
|
| """
|
| import argparse
|
| import sys
|
| from pathlib import Path
|
|
|
| import numpy as np
|
| import pandas as pd
|
|
|
| ROOT = Path(__file__).resolve().parents[1]
|
| sys.path.insert(0, str(ROOT))
|
|
|
| from src.dataset import Dataset
|
| from src.physics_engine import grounded_solve
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
| parser.add_argument("--data", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
|
| parser.add_argument("--episode", type=int, default=0)
|
| parser.add_argument("--step", type=int, default=500, help="step to inspect (snapped to a logged field step)")
|
| parser.add_argument("--router", default="potential", help="router whose telemetry is shown")
|
| args = parser.parse_args()
|
| pd.set_option("display.width", 160)
|
|
|
| ds = Dataset(args.data)
|
| ep = ds.episode(args.episode)
|
| print(ep)
|
| degree = np.bincount(ep.edges.ravel(), minlength=ep.n_nodes)
|
| print(f" degree min/mean/max {degree.min()}/{degree.mean():.2f}/{degree.max()}, "
|
| f"capacity {ep.capacity.min()}-{ep.capacity.max()} pkt/step, latency {ep.latency.min()}-{ep.latency.max()} steps, "
|
| f"total directed capacity {ep.row.total_capacity:.0f} pkt/step")
|
| rates = np.asarray(ep.row.flow_mean_rate)
|
| print(f" flows: {ep.n_flows} between {len(ep.topology.endpoints)} endpoints, offered load rho = {ep.row.offered_load:.3f}, "
|
| f"mean rate min/median/max {rates.min():.2f}/{np.median(rates):.2f}/{rates.max():.2f} pkt/step, "
|
| f"tracked flows {ep.tracked_flows}, field stride {ep.field_stride}")
|
|
|
| print(f"\nTopology events ({len(ep.events)}):")
|
| if len(ep.events):
|
| print(ep.events[["kind", "start", "end", "node", "edge_u", "edge_v", "factor"]].to_string(index=False))
|
| else:
|
| print(" none (static dynamics level)")
|
|
|
| print("\nRouter summary:")
|
| summary = ep.telemetry("router_summary").set_index("router")
|
| print(summary[["loss_ratio", "mean_delay", "p99_delay", "mean_queue", "max_queue",
|
| "link_utilisation", "link_saturation", "route_changes"]].to_string())
|
| flows = ep.telemetry("flow_summary")
|
| assert (flows.offered == flows.delivered + flows.dropped + flows.in_flight).all()
|
| print(" [ok] packet conservation holds for every flow and router")
|
|
|
| step = ep.nearest_logged_step(args.step)
|
| cap = ep.capacity_at(step)
|
| failed, degraded = int((cap == 0).sum()), int((cap < ep.capacity).sum() - (cap == 0).sum())
|
| print(f"\nStep {step} (nearest logged field step to {args.step}): {failed} failed links, "
|
| f"{degraded} links with reduced capacity, {len(ep.live_graph(step).src) // 2} live links")
|
| queue = ep.queue_depth(args.router)[step]
|
| busiest = np.argsort(-queue)[:5]
|
| print(f" busiest buffers under {args.router}: " + ", ".join(f"node {i}: {queue[i]}" for i in busiest))
|
| util = ep.link_utilisation(args.router)[step]
|
| flat = np.nan_to_num(util, nan=-1).ravel()
|
| top = np.argsort(-flat)[:5]
|
| print(" most utilised directed links: " + ", ".join(
|
| f"{ep.edges[k // 2, k % 2]}->{ep.edges[k // 2, 1 - k % 2]}: {flat[k]:.0%}" for k in top))
|
|
|
| stored = ep.field(step)
|
| queue_potential = ep.queue_depth("potential")[step]
|
| recomputed = ep.solve_field(step, queue_potential)
|
| rel = np.abs(recomputed - stored).max() / np.abs(stored).max()
|
| assert rel < 1e-5, rel
|
| print(f" [ok] potential field of the {ep.tracked_flows} tracked flows recomputed from graph state + queues "
|
| f"(max relative deviation from the stored float32 snapshot {rel:.1e})")
|
| g = ep.live_graph(step)
|
| b = (ep.config.background_injection / (ep.n_nodes - 1)
|
| + ep.config.congestion_gain * queue_potential.astype(np.float64) / ep.config.buffer_size)
|
| b[ep.source[0]] += ep.config.source_injection
|
| reference = grounded_solve(g, int(ep.sink[0]), b)
|
| assert np.abs(reference - recomputed[0]).max() < 1e-9 * max(1.0, np.abs(reference).max())
|
| print(" [ok] pseudo-inverse solution agrees with the sparse SuperLU solve for flow 0")
|
|
|
| s, t = int(ep.source[0]), int(ep.sink[0])
|
| path = ep.descent_path(step, recomputed[0], s, t)
|
| phi = recomputed[0][path]
|
| assert path[0] == s and path[-1] == t and np.all(np.diff(phi) < 0) and len(path) <= ep.n_nodes
|
| print(f" [ok] steepest-current descent of flow 0 reaches its sink: {' -> '.join(map(str, path))} "
|
| f"({len(path) - 1} hops, shortest possible {int(flows.min_hops.iloc[0])}); potentials "
|
| + " > ".join(f"{p:.4f}" for p in phi))
|
| tracked = flows[(flows.router == args.router) & (flows.flow < ep.tracked_flows)]
|
| print(f"\nTracked flows under {args.router}:")
|
| print(tracked[["flow", "source", "sink", "mean_rate", "min_hops", "offered", "delivered", "dropped",
|
| "loss_ratio", "mean_delay", "mean_queueing_delay", "mean_hops", "route_changes"]].to_string(index=False))
|
| print("\nAll checks passed.")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
