| ---
|
| license: mit
|
| pretty_name: Semantic Potential Routing Telemetry
|
| language:
|
| - en
|
| task_categories:
|
| - time-series-forecasting
|
| - tabular-regression
|
| - graph-ml
|
| tags:
|
| - networking
|
| - routing
|
| - graph-theory
|
| - operations-research
|
| - physics-based-simulation
|
| - telemetry
|
| - microbursts
|
| - data-center-networks
|
| - benchmark
|
| - synthetic
|
| size_categories:
|
| - 100M<n<1B
|
| configs:
|
| - config_name: router_summary
|
| data_files: data/router_summary/*.parquet
|
| - config_name: flow_summary
|
| data_files: data/flow_summary/*.parquet
|
| - config_name: episodes
|
| data_files: data/episodes/*.parquet
|
| - config_name: events
|
| data_files: data/events/*.parquet
|
| - config_name: network_telemetry
|
| data_files: data/network_telemetry/*.parquet
|
| - config_name: flow_telemetry
|
| data_files: data/flow_telemetry/*.parquet
|
| - config_name: link_telemetry
|
| data_files: data/link_telemetry/*.parquet
|
| - config_name: potential_field
|
| data_files: data/potential_field/*.parquet
|
| ---
|
|
|
| # Semantic Potential Routing Telemetry
|
|
|
| **Version 2.0** — a systematic, packet-level benchmark of **training-free potential-field routing** against
|
| classical routing under stochastic congestion, dynamic topologies and microburst traffic.
|
|
|
| Every episode is a network simulation in which routing is a physical field: each flow's destination is the
|
| grounded, attractive well of a discrete Poisson equation on the graph Laplacian, congested buffers inject
|
| repulsive current, and packets follow the resulting routing gradient without any learned weights. The same
|
| episode — identical topology, failure timeline and packet arrivals — is replayed under **six routers**: three
|
| potential-field variants (steepest descent, proportional multipath splitting, and a static ablation without
|
| congestion feedback) and three classical baselines (static shortest path, equal-cost multipath, and
|
| queue-aware adaptive shortest path). Episodes are laid out on a **full factorial design** over topology
|
| family, network size, traffic profile, offered load and topology dynamics, so every effect can be studied
|
| in isolation, and the recorded telemetry is step-resolved: buffer occupancy and drops of every node, load of
|
| every directed link, per-flow delivery and delay, and the potential field itself.
|
|
|
| Everything is generated on CPU with linear algebra and a vectorised queueing simulator: no GPU, no
|
| training, no external data. The generator ships in this repository, and any episode can be re-created bit
|
| for bit from `data/config.json` and its episode id.
|
|
|
| ## Experimental design
|
|
|
| Episodes belong to the cells of a five-factor factorial design (`src/design.py`). With the default 10
|
| replicates per cell the dataset holds **5 × 4 × 3 × 3 × 3 = 540 cells and 5,400 episodes**, each replayed
|
| under all six routers.
|
|
|
| | Factor | Levels | Meaning |
|
| |---|---|---|
|
| | `topology` | `barabasi_albert`, `watts_strogatz`, `erdos_renyi`, `waxman`, `fat_tree` | scale-free (router-level Internet), small-world, random, geometric ISP-like (distance latencies, coordinates), k-ary data-centre fabric (hosts are the endpoints, 2:1 oversubscribed edge) |
|
| | `size` | 32, 64, 128, 256 | nominal node count; fat-trees use k = 4, 6, 8, 10 (36, 99, 208, 375 nodes) |
|
| | `traffic_profile` | `poisson`, `microburst`, `sustained` | stationary Poisson; short intense bursts (peak/idle 16, mean 15-step bursts, 13 % duty); long moderate surges (peak/idle 4, 50 % duty) |
|
| | `load_level` | `light`, `moderate`, `heavy` | offered load ρ = 0.01, 0.03, 0.10 of the network's directed link capacity (defined below) |
|
| | `dynamics_level` | `static`, `moderate`, `severe` | no events; link failures and node degradations at 0.002/step each lasting 50–200 steps; 0.01/step lasting 100–400 steps |
|
|
|
| Episode `e` maps deterministically to cell `e mod 540` and replicate `e div 540`, so any prefix of the
|
| episode range — including a partially generated or resumed dataset — covers all cells evenly. Replicates
|
| are assigned to splits by `replicate mod 5`: 0–2 train, 3 validation, 4 test (60/20/20), recorded in
|
| `episodes.split`. Random families are generated at a common mean degree of 6, so network size is the only
|
| structural quantity that changes with the size factor.
|
|
|
| ## Tables
|
|
|
| The dataset is a relational schema of eight Parquet tables, one folder each under `data/`, sharded by
|
| episode (`part-00000.parquet`, …) and served as separate configurations on the Hub, so you download only
|
| what you need. Node ids are `0 … n_nodes−1`, flows `0 … n_flows−1`, and one step is one millisecond of
|
| simulated time. Every telemetry row carries `episode_id`, `router` and `step`.
|
|
|
| **`episodes`** — one row per episode: design cell (`cell_id`, `replicate`, `split`, `topology`, `size`,
|
| `traffic_profile`, `load_level`, `dynamics_level`), dimensions (`n_nodes`, `n_edges`, `n_flows`,
|
| `tracked_flows`, `steps`, `field_stride`), `offered_load` (ρ) and `total_capacity` (Σ directed link
|
| capacity), the static graph (`edge_u`, `edge_v` with `u < v` in a fixed order; per-link `capacity` in
|
| packets/step and `latency` in steps; `node_role` 0 router / 1 core / 2 aggregation / 3 edge / 4 host;
|
| `node_x`, `node_y` for Waxman graphs, empty otherwise) and the flows (`flow_source`, `flow_sink`,
|
| `flow_mean_rate`, `flow_idle_rate`, `flow_burst_rate`, plus the MMPP transition probabilities
|
| `p_idle_to_burst`, `p_burst_to_idle`, zero for the Poisson profile).
|
|
|
| **`events`** — one row per topology event, active for `start <= step < end`: `kind` (`link_failure`: the
|
| link's capacity is 0; `node_degradation`: all links of `node` are scaled by `factor`), `edge_u`/`edge_v` or
|
| `node` (−1 where not applicable).
|
|
|
| **`router_summary`** — one row per (episode, router): `offered`, `delivered`, `dropped`, `in_flight`,
|
| `loss_ratio`, `mean_delay`, `p99_delay`, `mean_queue`, `max_queue`, `link_utilisation` (packets forwarded /
|
| directed link capacity over all link-steps), `link_saturation` (fraction of directed link-steps at full
|
| capacity), `route_changes` (next-hop table entries that changed, summed over steps and flows).
|
|
|
| **`flow_summary`** — one row per (episode, router, flow): `source`, `sink`, `mean_rate`, `min_hops`,
|
| `min_latency` (shortest path on the base graph), `offered`, `delivered`, `dropped`, `in_flight`,
|
| `loss_ratio`, `mean_delay`, `delay_std`, `p50_delay`, `p95_delay`, `p99_delay`, `max_delay`,
|
| `mean_queueing_delay`, `mean_path_latency` (delay = queueing + propagation), `mean_hops`, `route_changes`.
|
|
|
| **`network_telemetry`** — one row per (episode, router, step): network totals `offered`, `admitted`,
|
| `delivered`, `dropped`, `queued`, `in_transit`, `mean_delay` (of packets delivered this step, NaN if none),
|
| `route_changes`, and two lists of length `n_nodes`: `queue_depth` (buffer occupancy after the step's
|
| arrivals were admitted and before forwarding, i.e. what the router sees) and `node_dropped`.
|
|
|
| **`flow_telemetry`** — one row per (episode, router, step, tracked flow) for the first `tracked_flows` (8)
|
| flows of every episode: `mmpp_state` (0 idle, 1 burst), `offered`, `admitted`, `delivered`, `dropped`,
|
| `queued`, `in_transit`, `mean_delay`, `route_changes`.
|
|
|
| **`link_telemetry`** — one row per (episode, router, step): `load_uv` and `load_vu`, lists of length
|
| `n_edges` with the packets forwarded over each link in the `u → v` and `v → u` directions.
|
|
|
| **`potential_field`** — one row per logged step of the `potential` router: `potential`, a list of
|
| `tracked_flows × n_nodes` float32 values, flow-major, with φ = 0 at each flow's sink. Steps are logged every
|
| `field_stride` steps (2 for 32-node graphs, 12 for the largest fat-trees) so that each episode's field
|
| stays within 1 MB; any step and any flow can be recomputed exactly from the other tables (see below).
|
|
|
| With the defaults, `flow_telemetry` holds about 260 M rows (5,400 episodes × 6 routers × 1,000 steps × 8
|
| tracked flows) and `network_telemetry` and `link_telemetry` 32.4 M each; the whole dataset is roughly 20 GB,
|
| three quarters of it the two per-step list tables. The summary tables are a few hundred MB and answer most
|
| benchmark questions on their own. **None of the step-level tables fits in memory** — read them with column
|
| projection and `episode_id` / `router` filters, or stream them shard by shard as
|
| `scripts/validate_dataset.py` does.
|
|
|
| All list columns (`queue_depth`, `node_dropped`, `load_uv`, `load_vu`, `capacity`, `latency`, …) are
|
| **int16** to keep the files small. Widen them before arithmetic — `np.stack(net.queue_depth) * 160`
|
| silently overflows, `np.stack(net.queue_depth).astype(float) * 160` does not.
|
|
|
| ## Simulation model
|
|
|
| **Topologies.** Barabási–Albert (m = 3), connected Watts–Strogatz (k = 6, p = 0.1) and Erdős–Rényi
|
| (p = 6/(n−1)) graphs; Waxman graphs with uniformly random coordinates in the unit square and link
|
| preference exp(−d / 0.15√2), drawn with an exact edge count for mean degree 6 and latency proportional to
|
| distance; and k-ary fat-trees (k²/4 core, k² pod switches, k³/4 hosts) with 40 packets/step fabric links
|
| and 80 packets/step host links. Random-graph links have integer capacities uniform in 8–80 packets/step
|
| (≈ 100–1 000 Mb/s for 1 500-byte packets at 1 ms steps) and latencies uniform in 1–10 steps. A disconnected
|
| Erdős–Rényi or Waxman sample is stitched into one component by joining each stray component to the main
|
| one (closest pair of nodes for geometric graphs), which adds on average fewer than 0.2 links per graph
|
| below 128 nodes and about one link per graph at 256 nodes, so the node count is always the nominal one.
|
|
|
| **Dynamics.** Independently each step a link fails or a node degrades with the level's probability; failed
|
| links are chosen only among the non-bridge links of the live graph, so the network never partitions and the
|
| question of interest — how quickly traffic routes around the damage — is always well posed. A degraded node
|
| multiplies the capacity of all its links by a factor in 0.1–0.5. Effective capacities are
|
| `max(1, ⌊capacity × factor_u × factor_v⌋)`, or 0 while failed, and follow from `episodes` + `events`.
|
|
|
| **Traffic.** Each episode has two flows per endpoint node between distinct ordered (source, sink) pairs.
|
| Per-flow mean rates are log-normal (σ = 0.75, elephants and mice) and rescaled so that the offered load
|
| `ρ = Σ_f m_f · hops_f / Σ_links capacity` — the share of the network's directed capacity the flows would
|
| occupy on their shortest paths — equals the cell's level exactly. Each flow is a two-state Markov-modulated
|
| Poisson process whose idle and burst rates are derived from its mean rate and the profile's peak ratio and
|
| duty cycle, so profiles differ in burstiness at equal long-run load.
|
|
|
| **Queueing.** Every node owns one drop-tail FIFO buffer of 256 packets shared by all flows. Each step, in
|
| order: new packets are created at their sources; packets reaching a node this step are delivered if the
|
| node is their sink, otherwise admitted oldest-first while space remains, the rest dropped; buffers are
|
| logged and routing decisions taken; then every directed link forwards, oldest first, up to its capacity of
|
| the packets whose next hop crosses it (virtual output queueing, no head-of-line blocking). A packet
|
| forwarded at step `t` over a link of latency ℓ arrives at `t + ℓ`, so delay is propagation plus queueing,
|
| and a packet already on the wire is unaffected by a failure of that link. Traffic is open-loop: there is no
|
| congestion control, which is what makes the routers' behaviour under overload comparable.
|
|
|
| ## Routers
|
|
|
| | router | decision | recomputed | capacity-aware | congestion-aware | multipath |
|
| |---|---|---|---|---|---|
|
| | `potential` | link with the largest current I_ij = w_ij(φ_i − φ_j) | every step | yes | yes | no |
|
| | `potential_split` | packets sprayed in proportion to the positive currents | every step | yes | yes | yes |
|
| | `potential_static` | largest current of the field without congestion injection | topology change | yes | no | no |
|
| | `shortest_path` | Dijkstra on latency (OSPF-like) | topology change | no | no | no |
|
| | `ecmp` | round-robin over all equal-latency shortest-path next hops | topology change | no | no | yes |
|
| | `adaptive_shortest_path` | Dijkstra on latency + queue / capacity, quantised to 10⁻⁶ steps (ARPANET-style) | every step | partly | yes | no |
|
|
|
| **Potential field.** For flow *f* with source *s* and sink *t*,
|
|
|
| ```
|
| L_g φ = b, L = D − W, w_ij = capacity_ij / latency_ij (live links only)
|
| b_i = source_injection · [i = s] + background_injection / (N − 1) + congestion_gain · queue_i / buffer_size
|
| ```
|
|
|
| where `L_g` is the weighted graph Laplacian with the sink's row and column removed — the Dirichlet condition
|
| φ_t = 0 that makes the sink the grounded well of the field (defaults 1.0, 0.5 and 2.0). The grounded inverse
|
| is available in closed form from the Laplacian pseudo-inverse, `(L_g⁻¹)_ij = L⁺_ij − L⁺_it − L⁺_tj + L⁺_tt`,
|
| and because the background and congestion injections are shared by all flows, the fields of all flows follow
|
| from one matrix–vector product with L⁺ plus O(N) work per flow; L⁺ is formed once per topology change. On
|
| every live directed link the current is I_ij = w_ij(φ_i − φ_j). Since b_i > 0 at every non-sink node,
|
| Σ_j I_ij = b_i > 0: at least one current is positive and every positive-current link leads strictly
|
| downhill, so both potential rules are loop-free and reach the sink in at most N − 1 hops for *any*
|
| congestion pattern — congestion bends routes but can never trap a packet. Proportional splitting is the
|
| physically faithful rule (electrical current divides over parallel paths); it uses a low-discrepancy
|
| per-packet coordinate so that the split is exact and the simulation stays deterministic.
|
|
|
| **Baselines.** `shortest_path` is the classic link-state behaviour, blind to capacity and queues but
|
| reacting to failures. `ecmp` spreads packets over all equal-cost paths, the data-centre default. The
|
| adaptive baseline recomputes Dijkstra each step with link cost latency + queue/capacity, the queue-aware
|
| policy that famously oscillates; its `route_changes` make that visible. Together with `potential_static`,
|
| the suite separates the value of capacity awareness, congestion awareness and multipath.
|
|
|
| On the defaults, at moderate load with microbursts, mean loss over episodes is about 1 % for `potential`,
|
| under 0.5 % for `potential_split` and `adaptive_shortest_path`, 2–3 % for `potential_static` and around
|
| 10 % for `shortest_path` and `ecmp`. At heavy load every router loses packets: a few percent for the
|
| adaptive ones, about 20 % for the static potential field and a third or more for shortest path and ECMP.
|
| The multipath and static potential variants pay for their robustness with longer paths (path stretch
|
| about 1.4–1.5 against 1.2 for the others), and the adaptive routers change next hops several orders of
|
| magnitude more often than the static baselines.
|
|
|
| ## Generating the dataset
|
|
|
| Any Python ≥ 3.9 environment works; the commands below are written with forward slashes, which both
|
| PowerShell and POSIX shells accept.
|
|
|
| ```bat
|
| cd "<path to this repository>"
|
| pip install -r requirements.txt
|
| ```
|
|
|
| Check the whole pipeline end to end in about a minute — fifteen short episodes covering every topology
|
| family, traffic profile and router in a temporary folder that is deleted afterwards:
|
|
|
| ```bat
|
| python scripts/run_local_sweep.py --smoke
|
| ```
|
|
|
| Generate the dataset (5,400 episodes on every logical core, shards of 40 episodes streamed to `data/`):
|
|
|
| ```bat
|
| python scripts/run_local_sweep.py
|
| ```
|
|
|
| An episode costs roughly 3–7 s of CPU at size 32, 6–13 s at 64, 20–35 s at 128 and 60–100 s at 256
|
| (six routers, 1 000 steps; heavier load and larger fabrics cost more), i.e. about 4–5 CPU-hours per
|
| replicate: expect the default run to take **one night on an 8-core laptop** and to write about 20 GB.
|
| Keep the machine plugged in with sleep disabled. The sweep
|
| prints progress with an ETA, and if it is interrupted, running the same command again resumes with the
|
| missing shards; when it finishes it writes `data/manifest.json` (provenance, coverage, table sizes) and
|
| prints the router benchmark. `data/config.json` binds the folder to its configuration, so a changed setting
|
| must go to another `--out` folder.
|
|
|
| Every design level and model knob is a flag (`python scripts/run_local_sweep.py --help`). A half-size run
|
| with exact 60/20/20 splits, a smaller design, or a potential-field-only run:
|
|
|
| ```bat
|
| python scripts/run_local_sweep.py --replicates 5
|
| python scripts/run_local_sweep.py --sizes 32,64 --topologies barabasi_albert,fat_tree --out data_small
|
| python scripts/run_local_sweep.py --routers potential,shortest_path --out data_pair
|
| ```
|
|
|
| Requirements: Python ≥ 3.9 with NumPy, SciPy, pandas, PyArrow, NetworkX, huggingface_hub and, for the
|
| figures, Matplotlib (`requirements.txt`). Workers use one BLAS thread each; all parallelism comes from the
|
| process pool.
|
|
|
| ## Validating a generated dataset
|
|
|
| `scripts/validate_dataset.py` is the test suite of a data folder. It re-derives every quantity it can from
|
| an independent path and compares, rather than merely re-reading what the generator wrote:
|
|
|
| ```bat
|
| python scripts/validate_dataset.py :: validates data/
|
| python scripts/validate_dataset.py --out data_small --resimulate 5
|
| ```
|
|
|
| | Group | What is checked |
|
| |---|---|
|
| | Structure | every table has the same number of shards; `manifest.json` present |
|
| | Design coverage | all cells present, replicates balanced to ±1, episode ids unique, the three splits present |
|
| | Invariants | `offered = delivered + dropped + in_flight`; loss ratio in [0, 1]; `mean_delay ≥ min_latency` and `mean_hops ≥ min_hops`; delay quantiles ordered; `mean_delay = mean_queueing_delay + mean_path_latency`; `flow_summary` sums to `router_summary`; `network_telemetry` and `flow_telemetry` sum to their summaries per (episode, router[, flow]); `admitted ≤ offered` on every step; link utilisation and saturation in [0, 1] |
|
| | Physical bounds (sampled episodes) | buffer occupancy within `buffer_size`; per-node drops sum to the step total; link loads never exceed the capacity in force at that step (recomputed from `episodes` + `events`); potentials non-negative and exactly 0 at each flow's sink |
|
| | Reproducibility | sampled episodes re-simulated from `config.json` alone and compared **bit for bit**, every table and column (NaN equal to NaN) |
|
| | Field reconstruction | one stored `potential_field` snapshot recovered from the graph state and queue depths with the sparse SuperLU reference solver, independent of the pseudo-inverse path used by the generator |
|
|
|
| Sampled episodes are the smallest, the largest and one drawn at random (`--seed`); `--resimulate` sets how
|
| many are re-simulated. Every line is printed as `[ok ]` or `[FAIL]`, the script exits **1** with a summary
|
| of the failures if anything is wrong, and a failing cross-table sum names the first group that differs
|
| (abridged output of a full default run):
|
|
|
| ```
|
| Structure
|
| [ok ] 135 shards present
|
| [ok ] every table has every shard
|
| [ok ] manifest.json present
|
| Design coverage
|
| [ok ] all 540 design cells present
|
| [ok ] balanced: 10-10 episodes per cell
|
| [ok ] episode ids unique
|
| [ok ] splits present: ['test', 'train', 'validation']
|
| Invariants
|
| [ok ] flow conservation: offered = delivered + dropped + in-flight
|
| ...
|
| [ok ] tracked-flow telemetry sums to the flow summary
|
| [ok ] admitted <= offered
|
| Physical bounds (sampled episodes)
|
| [ok ] episode 0: queue depths within the buffer
|
| [ok ] episode 0: link loads never exceed the capacity in force
|
| [ok ] episode 0: potentials non-negative and zero at the sinks
|
| Reproducibility (re-simulating from config.json)
|
| [ok ] episode 0: every table reproduced bit for bit
|
| Potential-field reconstruction (sparse reference solver)
|
| [ok ] episode 0, step 100: stored field matches the sparse solve (max rel err 4.5e-08)
|
|
|
| Dataset v2.0: 5400 episodes, 20.14 GB
|
| All checks passed.
|
| ```
|
|
|
| **Memory.** The cross-table checks never load a step-level table. The shards are scanned one record batch
|
| at a time (`--batch-rows`, default 262,144) and folded into a dense accumulator whose size is fixed by the
|
| design — episodes × routers × tracked flows, about 260 k slots — not by the 260 M rows being read. Peak
|
| resident memory is therefore flat in dataset size: **well under 1 GB** for the full 20 GB dataset, of which
|
| the PyArrow buffers are about 20 MB. The invariant pass costs roughly a minute per 10 GB on one core; the
|
| re-simulation of a few episodes dominates the total runtime.
|
|
|
| A quick end-to-end rehearsal of generation *and* validation, in about two minutes:
|
|
|
| ```bat
|
| python scripts/run_local_sweep.py --out data_tiny --sizes 32 --replicates 5 --steps 200 --shard_episodes 25
|
| python scripts/validate_dataset.py --out data_tiny
|
| python examples/benchmark_routers.py --data data_tiny
|
| ```
|
|
|
| ## Using the data
|
|
|
| ```python
|
| import numpy as np, pandas as pd
|
|
|
| rs = pd.read_parquet("data/router_summary")
|
| ep = pd.read_parquet("data/episodes").set_index("episode_id")
|
| df = rs.join(ep[["topology", "size", "traffic_profile", "load_level", "dynamics_level", "split"]], on="episode_id")
|
| print(df.pivot_table(index=["traffic_profile", "load_level"], columns="router", values="loss_ratio"))
|
|
|
| # One episode, step by step
|
| eid = 7
|
| net = pd.read_parquet("data/network_telemetry", filters=[("episode_id", "=", eid), ("router", "=", "potential")]).sort_values("step")
|
| queue = np.stack(net.queue_depth).astype(np.int32) # (steps, n_nodes); int16 on disk
|
| link = pd.read_parquet("data/link_telemetry", filters=[("episode_id", "=", eid), ("router", "=", "potential")]).sort_values("step")
|
| load = np.stack(link.load_uv).astype(np.int32) + np.stack(link.load_vu) # (steps, n_edges), both directions
|
| field = pd.read_parquet("data/potential_field", filters=[("episode_id", "=", eid)]).sort_values("step")
|
| row = ep.loc[eid]
|
| phi = np.stack(field.potential).reshape(-1, row.tracked_flows, row.n_nodes) # (snapshots, tracked flows, nodes)
|
| ```
|
|
|
| The graph state at any step — the N × N capacity matrix in force — follows from `episodes` and `events`:
|
|
|
| ```python
|
| def capacity_matrix(row, events, step):
|
| cap = row.capacity.astype(float).copy()
|
| factor, failed = np.ones(row.n_nodes), np.zeros(len(cap), bool)
|
| for e in events[(events.start <= step) & (step < events.end)].itertuples():
|
| if e.kind == "node_degradation":
|
| factor[e.node] *= e.factor
|
| else:
|
| failed |= (row.edge_u == e.edge_u) & (row.edge_v == e.edge_v)
|
| cap = np.maximum(1, np.floor(cap * factor[row.edge_u] * factor[row.edge_v]))
|
| cap[failed] = 0
|
| A = np.zeros((row.n_nodes, row.n_nodes))
|
| A[row.edge_u, row.edge_v] = A[row.edge_v, row.edge_u] = cap
|
| return A
|
|
|
| events = pd.read_parquet("data/events", filters=[("episode_id", "=", eid)])
|
| A = capacity_matrix(row, events, step=500)
|
| ```
|
|
|
| The same reconstruction, the telemetry of any router and an exact recomputation of the field of any flow at
|
| any step are one call each in the read API:
|
|
|
| ```python
|
| from src.dataset import Dataset
|
|
|
| ds = Dataset("data")
|
| ep = ds.episode(7)
|
| A = ep.capacity_matrix(500) # the graph state at step 500
|
| queue = ep.queue_depth("potential") # (steps, n_nodes)
|
| phi = ep.solve_field(500, flows=[0, 1, 2]) # exact field of any flows at any step
|
| path = ep.descent_path(500, phi[0], ep.source[0], ep.sink[0])
|
| ```
|
|
|
| `scripts/validate_dataset.py` checks such recomputations against the sparse SuperLU reference solver. From
|
| the Hub, each table is a configuration:
|
|
|
| ```python
|
| from datasets import load_dataset
|
| rs = load_dataset("<user>/<dataset>", "router_summary", split="train")
|
| ```
|
|
|
| Suggested uses: benchmarking routing policies on identical scenarios; forecasting queue build-up, drops
|
| or link saturation from step-level telemetry (`network_telemetry`, `link_telemetry`); learning graph
|
| surrogates of the potential field or of the routers' next-hop decisions (`potential_field` plus the graph
|
| state); studying route flapping of adaptive policies (`route_changes`); and out-of-distribution evaluation
|
| across topology families, sizes or dynamics levels using the factor columns of `episodes`.
|
|
|
| ## Examples
|
|
|
| `examples/` holds four scripts written against the small read API in `src/dataset.py` — `Dataset(path)`
|
| opens a data folder, `ds.table(name, columns, filters)` and `ds.summary(name)` return tables (the latter
|
| joined with the design factors and split), and `ds.episode(id)` bundles one episode: its graph, event
|
| timeline and flows, the capacities in force at any step (`capacity_at`, `live_graph`, `capacity_matrix`),
|
| its telemetry under any router (`queue_depth`, `node_dropped`, `link_load`, `link_utilisation`), the stored
|
| field (`field`) and an exact recomputation of the field of *any* flow at *any* step (`solve_field`,
|
| `next_hops`, `descent_path`). Every script runs on `data/` by default (`--data` selects another folder),
|
| prints its results, asserts the properties it relies on and ends with "All checks passed", so the set also
|
| serves as a usage test of a generated dataset.
|
|
|
| ```bat
|
| python examples/benchmark_routers.py :: paired router comparison with bootstrap intervals, per factor
|
| python examples/inspect_episode.py --episode 7 --step 500
|
| python examples/forecast_congestion.py :: ridge forecast of near-term loss on the splits
|
| python examples/visualize.py :: eight figures into figures/
|
| ```
|
|
|
| ### `benchmark_routers.py` — paired router comparison
|
|
|
| Compares every router with a reference (`--reference`, default `shortest_path`) on the identical episodes:
|
| mean loss and delay differences with 95 % bootstrap confidence intervals, win and tie rates, the loss ratio
|
| broken down by each design factor, and flow-level path stretch, latency stretch and queueing delay.
|
| `--csv figures/benchmark.csv` writes the per-episode joined summary. Abridged output:
|
|
|
| ```
|
| Paired differences to 'shortest_path' (negative = better; bootstrap 95 % CI over episodes):
|
| episodes loss_diff loss_ci_low loss_ci_high wins_loss delay_diff wins_delay
|
| router
|
| adaptive_shortest_path 675 -0.0770 -0.0863 -0.0681 0.4593 -0.8561 0.5837
|
| ecmp 675 -0.0082 -0.0107 -0.0059 0.3096 -0.1613 0.5244
|
| potential 675 -0.0685 -0.0766 -0.0601 0.4607 0.3886 0.3615
|
| potential_split 675 -0.0828 -0.0924 -0.0734 0.4637 2.6682 0.1630
|
| potential_static 675 -0.0409 -0.0472 -0.0352 0.4074 1.0377 0.1733
|
|
|
| Flow level (flows with at least one delivered packet):
|
| flows lossless_share path_stretch latency_stretch queueing_delay p99_delay
|
| potential 38879 0.9174 1.2646 1.2213 0.2678 11.0834
|
| potential_split 38879 0.9505 1.4912 1.6238 0.1118 23.9248
|
| potential_static 38879 0.8506 1.4371 1.2912 0.5299 11.4198
|
| shortest_path 38879 0.7846 1.2540 1.0038 1.6477 11.1648
|
| ecmp 38879 0.7945 1.2541 1.0038 1.5072 11.2295
|
| adaptive_shortest_path 38879 0.9359 1.1999 1.0494 0.2220 9.3849
|
| ```
|
|
|
| Read it as: the potential routers and the adaptive baseline cut loss by 4–8 percentage points against
|
| shortest path; the multipath split trades 2.7 steps of extra delay and 49 % path stretch for the lowest
|
| loss of all; the win rates are below 0.5 only because at light load more than half the episode pairs are
|
| exact ties (`ties_loss`, printed in the full table). The numbers above come from the two-minute rehearsal
|
| run (675 size-32 episodes, 200 steps), so they are noisier and lossier than a full sweep — the *ordering*
|
| of the routers is what reproduces.
|
|
|
| ### `inspect_episode.py` — one episode, checked against the physics
|
|
|
| Prints the design cell, graph, flows, event timeline and router summary; then, at one step, the capacities
|
| in force, the busiest buffers and links; recomputes the tracked flows' potential field from the graph state
|
| and queue depths and asserts it against the stored snapshot *and* the sparse reference solver; and follows
|
| one flow's steepest-current descent to its sink.
|
|
|
| ```
|
| Episode 7 [barabasi_albert/32/poisson/heavy/moderate] 32 nodes, 87 links, 64 flows, 200 steps, split=train
|
| degree min/mean/max 3/5.44/16, capacity 8-80 pkt/step, latency 1-10 steps, total directed capacity 7678 pkt/step
|
| flows: 64 between 32 endpoints, offered load rho = 0.100, tracked flows 8, field stride 1
|
|
|
| Topology events (1):
|
| kind start end node factor
|
| node_degradation 72 128 6 0.4374
|
|
|
| Step 100: 0 failed links, 9 links with reduced capacity, 87 live links
|
| busiest buffers under potential: node 0: 256, node 4: 189, node 6: 142
|
| [ok] potential field of the 8 tracked flows recomputed from graph state + queues (max rel dev 4.9e-08)
|
| [ok] pseudo-inverse solution agrees with the sparse SuperLU solve for flow 0
|
| [ok] steepest-current descent of flow 0 reaches its sink: 12 -> 1 -> 7 (2 hops, shortest possible 2);
|
| potentials 0.4934 > 0.4433 > 0.0000
|
| ```
|
|
|
| The last line is the loop-freedom guarantee made concrete: the potential decreases strictly along the path
|
| and the walk terminates at the sink.
|
|
|
| ### `forecast_congestion.py` — a learning task on the splits
|
|
|
| Predicts the network's loss ratio over the next `--horizon` steps from the last `--window` steps of
|
| `network_telemetry`, normalised by `total_capacity` so all sizes share one feature scale, with a closed-form
|
| ridge regression tuned on validation and reported on test against a persistence baseline:
|
|
|
| ```
|
| data/: router potential, window 10, horizon 10, stride 5
|
| samples: train 14,985 (405 episodes), validation 4,995 (135), test 4,995 (135); features 52
|
| Ridge penalty chosen on validation: lambda = 0.0001 (validation RMSE 0.0270)
|
| MAE RMSE R2
|
| ridge (validation) 0.0096 0.0270 0.8405
|
| persistence (validation) 0.0091 0.0325 0.7689
|
| ridge (test) 0.0099 0.0268 0.8285
|
| persistence (test) 0.0096 0.0342 0.7215
|
| ```
|
|
|
| As a squared-loss model the ridge wins on RMSE and R² while persistence keeps a marginally lower MAE on the
|
| many loss-free windows — a useful reminder to state the metric before claiming a win. The script asserts
|
| that the splits are disjoint by episode and that no feature is undefined.
|
|
|
| ### `visualize.py` — the figure gallery
|
|
|
| Draws eight PNGs into `figures/` (`--out`) with one fixed palette in which every router keeps its hue.
|
| Select a subset with `--figures`, and steer the single-episode panels with `--episode` (default: a busy
|
| one), `--step`, `--flow`, `--routers` (default `potential,shortest_path`) and `--dpi`:
|
|
|
| ```bat
|
| python examples/visualize.py --data data_small --figures potential_field,timeline --episode 12 --step 400
|
| ```
|
|
|
| | File | Shows |
|
| |---|---|
|
| | `topologies.png` | one graph per family, link width scaled by capacity |
|
| | `benchmark.png` | loss and mean delay per router at each load level, 95 % bootstrap intervals |
|
| | `timeline.png` | one episode step by step under two routers, with bursts and topology events marked |
|
| | `queue_heatmap.png` | buffer occupancy of every node over time, same episode, two routers side by side |
|
| | `link_utilisation.png` | CCDF of per-link-step utilisation: how often links run near saturation, per router |
|
| | `potential_field.png` | the field of one flow on the graph, node size = buffer occupancy, with the steepest-current next hops and the descent path |
|
| | `delays.png` | flow-level p99 delay and path stretch per router |
|
| | `traffic_profiles.png` | offered packets of one flow under each of the three profiles |
|
|
|
| 
|
|
|
| 
|
|
|
| 
|
|
|
| 
|
|
|
| ## Reproducibility and provenance
|
|
|
| Episode `e` draws every random quantity from `numpy.random.default_rng([seed, e])` in a fixed order and
|
| the routers are deterministic, so `scripts/validate_dataset.py` can re-simulate any episode and compare it
|
| bit for bit. The generator also avoids the two places where platforms usually disagree: shortest-path
|
| next hops are derived from Dijkstra *distances* (exact, because latencies and the quantised adaptive
|
| costs are integer-valued) with a fixed tie rule rather than from the solver's predecessor tie-breaking,
|
| and the potential routers resolve mathematically tied currents — common on symmetric fabrics — within a
|
| relative tolerance far above rounding noise. All twenty sample episodes generated during development were
|
| bit-identical under NumPy 1.26 / SciPy 1.11 and NumPy 2.4 / SciPy 1.17. `data/config.json` records the
|
| configuration and `data/manifest.json` the dataset version, library versions, platform, design coverage
|
| and table statistics of the shards present.
|
|
|
| ## Limitations
|
|
|
| Traffic is open-loop (no TCP-like feedback), nodes have a single shared drop-tail buffer, all packets
|
| have the same size, time is discretised to 1 ms steps and capacities to whole packets per step, and the
|
| topologies are synthetic families rather than measured networks. Routing tables are recomputed
|
| instantaneously with global knowledge, which is an upper bound on what a distributed implementation can
|
| achieve. These choices keep the routers comparable and the episodes reproducible; they should be kept in
|
| mind when transferring conclusions to production networks.
|
|
|
| ## Publishing
|
|
|
| Uploading is the one manual step. Draw the figures this card embeds, log in once with a write token, then
|
| push the project folder — Parquet shards, `config.json`, `manifest.json`, this dataset card with its
|
| figures, and the generator and example source — as a dataset repository; the upload is resumable and its
|
| bookkeeping lives in `.cache/`:
|
|
|
| ```bat
|
| python examples/visualize.py
|
| hf auth login
|
| python scripts/push_to_huggingface.py --repo <user>/<dataset>
|
| ```
|
|
|
| Add `--private` for a private repository. The `configs:` block at the top of this file makes every table
|
| browsable in the Dataset Viewer as soon as the upload finishes.
|
|
|
| ## Repository layout
|
|
|
| ```
|
| ├── README.md dataset card and this guide
|
| ├── requirements.txt
|
| ├── .gitignore keeps generated data and caches out of git
|
| ├── src/
|
| │ ├── design.py factors, levels, episode → cell / replicate / split
|
| │ ├── config.py every knob of the generator, one frozen dataclass
|
| │ ├── graph_generator.py five topology families, connectivity-preserving event timelines
|
| │ ├── physics_engine.py Laplacian potential field, routing gradient, multipath spraying, baselines
|
| │ ├── simulation_loop.py traffic, vectorised packet queueing, six routers, multiprocessing sweep
|
| │ ├── telemetry_logger.py Parquet schemas, sharded resumable writing, manifest
|
| │ └── dataset.py read API: tables, episodes, graph state and field at any step
|
| ├── scripts/
|
| │ ├── run_local_sweep.py generate (automatic, resumable)
|
| │ ├── validate_dataset.py verify a generated dataset
|
| │ └── push_to_huggingface.py publish (manual)
|
| ├── examples/
|
| │ ├── benchmark_routers.py paired router benchmark
|
| │ ├── inspect_episode.py one episode end to end, checked against the physics
|
| │ ├── forecast_congestion.py loss forecasting on the splits
|
| │ └── visualize.py figure gallery
|
| ├── figures/ drawn by examples/visualize.py
|
| └── data/ generated shards, one folder per table, plus config.json and manifest.json
|
| ```
|
|
|
| ## Changelog
|
|
|
| **2.0** — full factorial design over five topology families, four sizes, three traffic profiles, three
|
| offered-load levels and three dynamics levels with balanced replicates and 60/20/20 splits; six routers
|
| (three potential-field variants, three classical baselines); two flows per endpoint with log-normal rates
|
| and offered load defined relative to network capacity; potential fields via the Laplacian pseudo-inverse
|
| (exact, O(N·F) per step); per-link loads, per-node drops, queueing/propagation delay decomposition, route
|
| changes, network-level per-step totals; manifest with provenance and coverage; validation script.
|
|
|
| **1.0** — 1,000 Barabási–Albert episodes with four flows, potential field vs. shortest path, six tables.
|
|
|
| Tooling fixes since the 2.0 data release (the Parquet schemas and the generated data are unchanged, so no
|
| regeneration is needed): the cross-table invariant checks in `scripts/validate_dataset.py` now stream the
|
| shards into a dense per-group accumulator instead of loading `flow_telemetry` into pandas, which exhausted
|
| memory on the full dataset, and they report the first group that differs when a sum disagrees; the
|
| potential-field figure widens the int16 `queue_depth` before scaling it into marker sizes, which previously
|
| overflowed and hid the busiest nodes.
|
|
|
| ## Design notes
|
|
|
| The original blueprint solved `L φ = b` on the full Laplacian, which is singular and only consistent when
|
| `b` sums to zero — a condition that congestion injections break. Grounding the sink removes the
|
| singularity, gives the sink its physical meaning as the well of the field and yields the loop-freedom
|
| guarantee above. Choosing the next hop by the largest current rather than the lowest neighbouring
|
| potential makes the decision conductance-aware, so a low-capacity or high-latency link is not chosen merely
|
| because its far end sits at a low potential. Telemetry is streamed straight to Parquet in atomic, resumable
|
| shards, which is what the Hub reads natively and makes a separate HDF5 staging layer unnecessary.
|
|
|
