gnn_dataset — MATSim training data for a GNN surrogate (Zurich cutout)

Runs many MATSim scenarios on Euler and stores per scenario a compact dataset (population, network, hourly link loads) as parquet. Nothing in the pipeline itself is modified; everything lives in this directory.

How it works

1. Base (once) — sbatch sbatch/build_base.sbatch runs the eqasim pipeline up to matsim.cutter.run at 2 % (a generated copy of config.yml, the original is untouched), cuts the canton of Zurich (extent/zurich_canton.shp, built from swissBOUNDARIES3D), and harvests zurich_*.xml.gz + config + the eqasim jar into $SCRATCH/gnn_runs/base/. It also builds pool_persons.parquet (attributes + home municipality). The 2 % pool exists so that class-3 scenarios can draw 0.5 / 1 / 2 % samples without ever re-running the pipeline; the baseline is a fixed 1 % draw (pop_seed 0) of that pool.
2. Scenarios — python generate_scenarios.py writes scenarios/<id>/scenario.json for the whole campaign, deterministic from config.yaml: generator_seed.
3. Run — python submit_array.py ... submits one Slurm array task per scenario (run_scenario.py): materialize (modified network / population XML
   • config overrides) → RunSimulation → extract parquets → delete output_events.xml.gz + ITERS/ → copy parquets to data/<id>/.
4. Manifest — python build_manifest.py → manifest.parquet (status ok/failed/running, path, class, runtime, core-hours, error).

Scenario classes

class	id	perturbation
0	base_s0..4	identical baseline, different MATSim seed (simulation variance)
1	c1_*	1–5 closures of car links with capacity ≥ 1000 veh/h, never PT-carrying links. Variant: capacity → 0 (kept in the network: capacity 1 veh/h, freespeed 1 m/s so the router avoids it). Removing links crashes MATSim when routes reference them.
2	c2_*	5–20 random car links, capacity × {0.5, 0.75, 1.5} (factor drawn per link)
3	c3_*	other population seed and/or rate ∈ {0.5, 1, 2 %}; with p=0.5 also one random municipality scaled × {0.7, 1.3} (implemented as a differential draw rate inside that zone)

flowCapacityFactor = rate, storageCapacityFactor = rate^0.75 (eqasim's rule), both recorded in every scenario.json.

Per-scenario files (data/<id>/)

• scenario.json — id, class, seed, matsim_seed, pop_seed, sample_rate, capacity factors, iterations, eqasim commit, all perturbation parameters, population selection stats
• nodes.parquet — node_id, x, y
• links.parquet — link_id, from_node, to_node, length, freespeed, capacity, lanes, modes, closed, capacity_factor
• persons.parquet — person_id, home_x/y, home_zone (BFS), age, employed, car_available, has_license, main activity type + x/y, is_freight
• link_hourly.parquet — link_id, hour, volume (scaled to 100 %), traveltime_avg, vc_ratio, congestion_index (from linkstats, averaged over the last 5 iterations). Sparse: only (link, hour) rows with volume > 0 are stored; a missing row means volume 0, free-flow travel time, vc_ratio 0, congestion_index 1. Compact dtypes (int8 hour, float32), zstd.
• delta_vs_baseline.parquet (class 1, 2) — Δ vc_ratio, Δ congestion_index vs base_s0 over the union of both sparse key sets; rows with zero change omitted
• scorestats.parquet — MATSim score trajectory (convergence check)

Demand tables (from the scenario's OWN population plans, build_demand.py; all counts are weight = 1/sample_rate-weighted, i.e. scaled to 100 %):

• persons.parquet additionally has work_x/y, edu_x/y (first work / education activity), n_legs (raw MATSim legs), n_trips (trips between non-interaction activities, the unit used by the OD tables), n_car_trips, weight
• cells.parquet — regular 500 m grid over the network bounding box (grid definition in scenario.json: demand.grid, cell_id = iy * nx + ix, EPSG:2056; identical for all scenarios). Per cell: cx, cy, residents, residents_employed, residents_car_available (carAvail always/sometimes), residents_age_0_17/18_64/65plus, jobs, edu_places, trips_origin, trips_dest. Empty cells are included (zeros). Home = the plan's first home activity, so agents cut by the scenario cutter (only outside activities) and freight agents are not residents. Source: the scenario's output_plans.xml.gz (plans after replanning, consistent with the measured loads; recorded in scenario.json: demand.source).
• od_cells.parquet — orig_cell, dest_cell, mode, trips (sparse, trips > 0; cell −1 = outside the grid). mode is the trip's routingMode (car, pt, walk, bike, car_passenger, truck, outside). od_cells_am.parquet: same for departures 06:00–09:00.
• cells_delta_vs_baseline.parquet (class 3) — cell values minus base_s0.
• ../cell_link_edges.parquet (ONCE at the dataset root, identical for all scenarios): cell_id, link_id, dist_m for every pair with |cell centre − link midpoint| ≤ radius (see cell_link_edges.json).

Operations

python generate_scenarios.py                 # after the base is ready
python submit_array.py base_s0               # baseline first
python -c "from gnnds.convergence import summarize; print(summarize('/cluster/scratch/rsahleanu/gnn_runs/base_s0/output/scorestats.csv'))"
python submit_array.py c1_000                # one test scenario -> runtime / core-h
python submit_array.py --class 1             # then the arrays
python submit_array.py --all --skip-done     # (re)run everything not yet ok
python build_manifest.py

Resources per task are in config.yaml: resources (override with --cores/--mem-mb/--time/--java-xmx/--max-parallel).

Campaign 2026-09-13 — results and caveats

155/155 scenarios ok (job array 14032547 + 14031605/06), 474 core-h total, median 45 min per scenario on 4 cores (26–79 min), MaxRSS 7.5 GB. manifest.parquet has runtime/core-hours/job id per scenario.

Convergence (scorestats.parquet, mean over all 155 runs of avg_executed): −45.8 (it 0) → −25.4 (it 30) → −25.3 (it 60). Relative change over 5 iterations: 1.1 % at it 30, 0.4 % at it 40, ≤ 0.2 % from it 45 on. Innovation is never switched off (fractionOfIterationsToDisableInnovation = Infinity), so scores keep fluctuating by ~±0.2 % around the plateau. 60 iterations are safe; ~45–50 would have sufficed.

Noise floor at 1 %. One sampled vehicle = 100 veh/h after scaling, i.e. 0.1 vc on a 1000 veh/h link. Seed-only differences (base_s1..4 vs base_s0) give mean |Δvc| = 0.09 per (link, hour) and 36 % of link-hours differ by

0.1; single closures (class 1) give 0.105 / 43 %. The perturbation signal is therefore local and small relative to per-link-hour seed noise — use the five baseline seeds to estimate that noise, aggregate over hours/links, or train on delta_vs_baseline with an appropriate loss. 14 of the 173 closed links carry no traffic in the baseline (closure has no effect); scenario.json + links.parquet: closed identify them.

Outliers. traveltime_avg / congestion_index can be extreme (up to ~10⁴×) on short links that gridlock in the QSim at this sample size (storage capacity factor 0.032 → most links hold a single vehicle). Clip or winsorize before training. PT-only links (pt_*, 2240 links, freespeed ∞) have congestion_index = NaN; filter links.parquet: modes for car links.

Scratch. $SCRATCH/gnn_runs/<id>/ keeps the materialized inputs and the non-event MATSim outputs (~200 MB each, 31 GB total); events and ITERS/ were deleted. Everything needed for training is in data/ (4.3 GB).

Loading in PyTorch

torch_dataset.py turns every scenario into one graph sample (needs numpy, pandas, pyarrow, torch; optional torch_geometric and scipy). Copy data/, manifest.parquet and torch_dataset.py to the training machine, then:

from torch_dataset import GNNScenarioDataset
from torch.utils.data import DataLoader          # or torch_geometric.loader.DataLoader

ds = GNNScenarioDataset("/path/to/gnn_dataset", targets="vc_ratio")   # 155 scenarios
ds.build_cache()                                  # once: parquet -> cache_torch/*.npz (a few s per scenario)
tr, va, te = ds.split(val_frac=0.15, test_frac=0.15, seed=0)          # stratified by class
sample = ds[tr[0]]
# sample.x [92019, 4]   node: x, y (normalised), n_home, n_activity (persons, scaled to 100 %)
# sample.edge_index [2, 181961]   car links, from -> to
# sample.edge_attr [181961, 7]    log_length, freespeed, log_capacity, lanes, closed, capacity_factor, capacity_eff
# sample.y [181961, 24]           target per link and hour; sample.y_base = same for base_s0
# sample.scenario                 dict from scenario.json
loader = DataLoader([ds[i] for i in tr], batch_size=1, shuffle=True)   # plain torch: returns dicts

With with_cells=True (default) every sample also carries the demand side: cell_x [13786, 12] (normalised centre + log1p of the 10 cell counts), cell_pos, cell_link_index [2, M] / cell_link_dist [M] (cell ↔ car-link pairs; cell_link_max_dist=2000 keeps 9.1 M pairs instead of 57 M for 5 km), od_index [2, K] / od_trips [K, 3] (all / car / AM-peak trips between cells inside the grid). The cell ↔ link pairs are read once from cell_link_edges.parquet and cached as npz.

targets may be a list (["vc_ratio", "congestion_index", "traveltime_avg"] → y is [E, 72]); congestion_index is clipped at clip_congestion (50) and NaN → 1. With car_only=False all 188 590 links are used. The network is the same in every sample, so a model can cache edge_index.