---
license: cc-by-4.0
pretty_name: MATSim Zurich GNN surrogate dataset
tags: [transportation, matsim, graph, gnn, traffic-simulation]
---
# 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

```bash
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:

```python
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`.