ezharjan/SemanticPotentialRoutingTelemetry

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.

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:

python scripts/run_local_sweep.py --smoke

Generate the dataset (5,400 episodes on every logical core, shards of 40 episodes streamed to data/):

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:

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:

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:

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

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:

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:

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:

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.

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:

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/:

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.