Datasets:

lilcheaty
/

dijkwalk-experiments

Tags:

Tighten dataset card prose

db6c405 verified 23 days ago

11.3 kB

---
pretty_name: dijkwalk experiments
tags:
- reinforcement-learning
- supervised-learning
- graph-algorithms
- dijkstra
- reward-shaping
- pufferlib
- size-generalization
---
# dijkwalk experiments

This dataset holds the checkpoints, training curves, and evaluation results for the
dijkwalk project. The project measures when directional reward shaping helps a learned
agent walk a weighted graph to a hidden target. It also compares the same exact Dijkstra
signal used as an RL reward and as a supervised training signal.

Code, tests, paper sources, and the visualizer are in the GitHub repository
<https://github.com/safzanpirani/dijkwalk>. This dataset holds the files that the
repository does not track: about 760 MB of `.pt` checkpoints and `.json` results from
183 paper training runs and 179 earlier exploratory runs. Console logs are not included.

## Task

Each episode places an agent on a random connected weighted graph. At every node the
agent sees at most the eight cheapest incident edges (K = 8) and must reach a hidden
target node. Invalid actions are masked, and every reported evaluation has an
invalid-action rate of exactly 0.

The exact Dijkstra regret is

    Δ(u, v) = w(u, v) + φ(v) − φ(u),    φ(x) = d(x, target)
The two paradigms use it differently:

- **Reinforcement learning** (PufferLib PPO) receives the per-step reward
  `−β·Δ / w_max`, where `w_max` is the largest edge weight. With β = 1 each move in the
  wrong direction costs its exact regret.
- **Supervised learning** trains a decoder-only sequence model with teacher forcing. The
  `soft_kl` variant in this dataset uses Δ as a per-token teacher signal at temperature
  τ = 1.0.

## Headline results

The GitHub repository has the full tables, gate audits, and figures under `paper/` and
`paper-results/`.

| Question | Gate | Outcome |
|---|---|---|
| Q1: Δ as reward versus as loss weight | >5-point success, >0.5 opt-gap, or different size degradation | Pass |
| Q2: reward-shaping phase diagram | ≥15-point graded-minus-sparse success with non-overlapping seed ranges | Null result |
| Q3: size generalization | >80% success at ≥8× training size while another architecture collapses | Pass |
| Q4: rigor and controls | three seeds, deterministic seed path, classical baselines | Complete |

**Q1, RL versus supervised.** At 25M matched training compute with sampled decoding, RL
beats supervised learning in all six cells, and the gap widens as graphs get larger.

| Scale | Suite | RL | Supervised | RL advantage |
|---|---|---:|---:|---:|
| small | train scale | 97.2% | 76.0% | +21.3 pp |
| small | near OOD | 95.8% | 53.3% | +42.4 pp |
| small | far OOD | 90.8% | 12.8% | +78.0 pp |
| large | train scale | 96.4% | 90.9% | +5.5 pp |
| large | near OOD | 92.5% | 62.7% | +29.9 pp |
| large | far OOD | 87.6% | 31.3% | +56.2 pp |

With greedy decoding, far-OOD success is 79.1% for RL and 4.7% for supervised at the
small scale, and 69.2% and 6.3% at the large scale. Compute matches within 1.4%, and
parameter counts differ by at most 1.2%.

**Q2, phase diagram.** The strongest cell is cold-start graphs (n = 32 to 64) with a
`1.25n` step horizon. Graded shaping beats sparse reward there by 11.5, 12.2, and 12.4
points at goal bonuses of 10, 1, and 0. The seed ranges separate, and no cell reaches the
15-point gate. A binary backward penalty matches graded shaping in the strongest
main-grid cell.

**Q3, size generalization.** Policies trained on graphs up to n = 32 are evaluated up to
n = 768. At 24 times the maximum training size, sampled success is 90.9% for the MLP,
93.6% for the LSTM, and 56.1% for the Transformer. When the Transformer succeeds, its
paths are cheaper (opt gap 22.5 against 50.1 for the MLP). More than 92% of sampled
n = 768 episodes contain a two-cycle for every learned architecture.

## Repository layout

```
README.md
experiments/                 179 exploratory training runs (early sweeps, ablations, smoke runs)
viz-data/
  experiments.json           merged ablation curves used by the visualizer
  experiments-*.json         per-run curve files behind that merge
  policy-mlp.{json,pt}       policy-architecture comparison runs
  policy-transformer.{json,pt}
  q1-supervised/             supervised training runs and their evaluations
  q1-rl/                     RL training runs at the 25M budget and their evaluations
  q1-eval/                   aggregated Q1 tables (rl.json, supervised.json, rl-5m.json)
  q2/                        54 main-grid runs plus the goal-bonus extension (162 total)
  q3/                        size-generalization runs and evaluations
```

File counts, excluding logs: `experiments/` 537, `q1-supervised/` 54, `q1-rl/` 24,
`q1-eval/` 15, `q2/` 327, `q3/` 30.

## Experiment details

### Q1: cross-paradigm comparison (`q1-rl/`, `q1-supervised/`, `q1-eval/`)

| Arm | Model | Parameters | Paired with |
|---|---|---:|---|
| RL | LSTM policy | 183,081 | supervised small |
| RL | Transformer policy | 531,202 | supervised large |
| Supervised | small sequence model | 185,192 | RL LSTM |
| Supervised | large sequence model (d_model 72, 7 layers, 8 heads, vocab 113, max sequence 1024) | 532,152 | RL Transformer |
Each arm trains with seeds 42, 43, and 44. The RL checkpoints are named
`q1-25m-shaping-beta1-seed*.pt` (LSTM) and `q1-25m-policy-transformer-seed*.pt`. The
supervised checkpoints are named `q1-soft-kl-{small,large}-train20000-seed*.pt`.
Three frozen 1,000-graph suites test every checkpoint. Each suite is pinned by SHA-256,
and every result row stores the hash in `suite_sha256`.

| Suite | Node count range |
|---|---|
| `train-scale` | 16 to 32 |
| `near-ood` | 33 to 48 |
| `far-ood` | 64 to 96 |

Each checkpoint is evaluated with greedy and sampled decoding under a step budget of
`4n`. That gives 180 fixed-suite conditions: 72 RL and 108 supervised.

### Q2: shaping phase diagram (`q2/`)

The main grid trains 54 five-million-step LSTM policies. It varies four factors:

- reward mode: graded Δ (`shaping-beta1`), the β = 0 control (`shaping-sparse`), and a
  binary backward penalty (`shaping-binary`);
- rollout horizon: `4n`, `2n`, and `1p25n` (1.25n);
- graph regime: `small` (fixed n = 8 to 16) and `cold` (cold-start n = 32 to 64);
- seeds 42, 43, and 44.

The extension repeats the grid at goal bonuses of 1 and 0, which gives 162 runs. Every
run uses the Muon optimizer at learning rate 0.015 with 1,024 parallel environments.

Run names follow `q2-{regime}-{horizon}-g{goal_bonus}-{mode}-seed{seed}`, for example
`q2-cold-1p25n-g0-shaping-beta1-seed42`. Each run has a `.json` curve file and a `.pt`
checkpoint. The files `grid-manifest.json`, `grid-g0-manifest.json`, and
`grid-g1-manifest.json` list every run with its final success rate.

### Q3: size generalization (`q3/`)

Nine five-million-step policies (MLP, LSTM, and Transformer, three seeds each) train on
graphs up to n = 32. They are evaluated on n = 32, 48, 96, 192, 384, and 768 with 1,000
graphs per condition, greedy and sampled decoding, and suite seed 20260726. The
checkpoints are `q3-policy-mlp-seed*.pt`, `q3-policy-transformer-seed*.pt`, and
`q3-shaping-beta1-seed*.pt` (the LSTM).

### Exploratory runs (`experiments/`)

This folder holds the runs from early in the project: the first ablation sweeps behind
the visualizer and several smoke and reproducibility runs. Each run has a directory named
by a numeric run id (`178120009848`) and a sibling final policy file
(`178120009848.pt`). Inside the directory, PufferLib writes intermediate checkpoints
(`model_000025.pt`) and the optimizer state (`trainer_state.pt`). These runs use
different settings from the paper runs. The paper results come from `viz-data/`.

## File formats

**Training curve files** (`q2/*.json`, `q3/experiments-*.json`, `viz-data/experiments*.json`)
hold `name`, `spec` (environment settings and recurrent wrapper), `n_params`, `seed`,
`tag`, `artifact_stem`, `steps`, `num_envs`, and `curve`. Each `curve` entry records
`agent_steps`, `epoch`, `SPS` (steps per second), `uptime`, and the PPO loss statistics
(`losses/policy_loss`, `losses/value_loss`, `losses/entropy`,
`losses/explained_variance`, `losses/approx_kl`).

**Evaluation files** (`eval-*.json`) hold `config`, `runs`, and `summary`. Each row in
`runs` describes one checkpoint on one suite and decoding mode:

| Field | Meaning |
|---|---|
| `episodes`, `successes`, `success_rate` | episodes run and how many reached the target |
| `episode_length` | mean steps per episode |
| `opt_gap` | mean path cost of successful episodes divided by the optimal cost |
| `backward_rate` | fraction of moves that increase φ |
| `two_cycle_rate`, `two_cycle_episode_rate` | share of moves in A→B→A cycles, and share of episodes containing one |
| `invalid_rate` | fraction of masked-invalid actions (0.0 everywhere) |
| `paradigm`, `architecture`, `training_budget`, `training_steps`, `train_seed` | which model produced the row |
| `suite`, `suite_sha256`, `n_min`, `n_max`, `decoding` | the evaluation conditions |
| `checkpoint`, `n_params` | source checkpoint file and its parameter count |

**Supervised run files** (`q1-supervised/q1-soft-kl-*.json`) hold the training
configuration (`variant`, `size`, `seed`, `steps`, `batch_size`, `tau`, `model`), the
final loss, a 200-point loss `curve`, and `captures`, a list of integer checkpoint
steps.

**Checkpoints** (`.pt`) are PyTorch files. `train.py eval --load-model-path <file>` in
the GitHub repository loads the RL checkpoints, and the supervised scripts in the same
repository load the supervised ones.

## Loading a file

```python
from huggingface_hub import hf_hub_download
import json
path = hf_hub_download(
    "lilcheaty/dijkwalk-experiments",
    "viz-data/q1-eval/rl.json",
    repo_type="dataset",
)
rows = json.load(open(path))["runs"]
far = [r for r in rows if r["suite"] == "far-ood" and r["decoding"] == "sampled"]
print(sum(r["success_rate"] for r in far) / len(far))
```

## Reproducing the runs

Clone the GitHub repository and follow its `README.md`. It covers setup, `train.py`, the
`scripts/q1_suite` verifier, and the per-question scripts under `scripts/`. The seed
controls Python, NumPy, PyTorch, PufferLib, graph generation, policy initialization, and
action sampling. Same-seed reruns produce tensor-identical checkpoints and identical
non-timing curves. Every seed appears in its filename, so concurrent runs never
overwrite each other.

## Caveats

- Greedy policies fall into two-cycles, so the headline numbers use sampled decoding.
  Greedy numbers are listed next to them where the paper reports both.
- The Q1 comparison matches compute and parameters closely. It does not separate the
  effect of the training signal from every optimizer and data-distribution difference
  between the two paradigms.
- The Q2 result is a null against a predeclared 15-point gate. The strongest cells show an
  8 to 12 point advantage for graded shaping.
- The Q1 runs trained on a remote GPU box with the official CUDA 12.6 PyTorch wheel.
  `paper/EXPERIMENT-SUMMARY.md` in the GitHub repository lists every operational
  deviation.

## Citation

No formal citation exists yet. Cite the GitHub repository:
<https://github.com/safzanpirani/dijkwalk>.

	---
	pretty_name: dijkwalk experiments
	tags:
	- reinforcement-learning
	- supervised-learning
	- graph-algorithms
	- dijkstra
	- reward-shaping
	- pufferlib
	- size-generalization
	---

	# dijkwalk experiments

	This dataset holds the checkpoints, training curves, and evaluation results for the
	dijkwalk project. The project measures when directional reward shaping helps a learned
	agent walk a weighted graph to a hidden target. It also compares the same exact Dijkstra
	signal used as an RL reward and as a supervised training signal.

	Code, tests, paper sources, and the visualizer are in the GitHub repository
	<https://github.com/safzanpirani/dijkwalk>. This dataset holds the files that the
	repository does not track: about 760 MB of `.pt` checkpoints and `.json` results from
	183 paper training runs and 179 earlier exploratory runs. Console logs are not included.

	## Task

	Each episode places an agent on a random connected weighted graph. At every node the
	agent sees at most the eight cheapest incident edges (K = 8) and must reach a hidden
	target node. Invalid actions are masked, and every reported evaluation has an
	invalid-action rate of exactly 0.

	The exact Dijkstra regret is

	Δ(u, v) = w(u, v) + φ(v) − φ(u), φ(x) = d(x, target)

	The two paradigms use it differently:

	- Reinforcement learning (PufferLib PPO) receives the per-step reward
	`−β·Δ / w_max`, where `w_max` is the largest edge weight. With β = 1 each move in the
	wrong direction costs its exact regret.
	- Supervised learning trains a decoder-only sequence model with teacher forcing. The
	`soft_kl` variant in this dataset uses Δ as a per-token teacher signal at temperature
	τ = 1.0.

	## Headline results

	The GitHub repository has the full tables, gate audits, and figures under `paper/` and
	`paper-results/`.

	\| Question \| Gate \| Outcome \|
	\|---\|---\|---\|
	\| Q1: Δ as reward versus as loss weight \| >5-point success, >0.5 opt-gap, or different size degradation \| Pass \|
	\| Q2: reward-shaping phase diagram \| ≥15-point graded-minus-sparse success with non-overlapping seed ranges \| Null result \|
	\| Q3: size generalization \| >80% success at ≥8× training size while another architecture collapses \| Pass \|
	\| Q4: rigor and controls \| three seeds, deterministic seed path, classical baselines \| Complete \|

	Q1, RL versus supervised. At 25M matched training compute with sampled decoding, RL
	beats supervised learning in all six cells, and the gap widens as graphs get larger.

	\| Scale \| Suite \| RL \| Supervised \| RL advantage \|
	\|---\|---\|---:\|---:\|---:\|
	\| small \| train scale \| 97.2% \| 76.0% \| +21.3 pp \|
	\| small \| near OOD \| 95.8% \| 53.3% \| +42.4 pp \|
	\| small \| far OOD \| 90.8% \| 12.8% \| +78.0 pp \|
	\| large \| train scale \| 96.4% \| 90.9% \| +5.5 pp \|
	\| large \| near OOD \| 92.5% \| 62.7% \| +29.9 pp \|
	\| large \| far OOD \| 87.6% \| 31.3% \| +56.2 pp \|

	With greedy decoding, far-OOD success is 79.1% for RL and 4.7% for supervised at the
	small scale, and 69.2% and 6.3% at the large scale. Compute matches within 1.4%, and
	parameter counts differ by at most 1.2%.

	Q2, phase diagram. The strongest cell is cold-start graphs (n = 32 to 64) with a
	`1.25n` step horizon. Graded shaping beats sparse reward there by 11.5, 12.2, and 12.4
	points at goal bonuses of 10, 1, and 0. The seed ranges separate, and no cell reaches the
	15-point gate. A binary backward penalty matches graded shaping in the strongest
	main-grid cell.

	Q3, size generalization. Policies trained on graphs up to n = 32 are evaluated up to
	n = 768. At 24 times the maximum training size, sampled success is 90.9% for the MLP,
	93.6% for the LSTM, and 56.1% for the Transformer. When the Transformer succeeds, its
	paths are cheaper (opt gap 22.5 against 50.1 for the MLP). More than 92% of sampled
	n = 768 episodes contain a two-cycle for every learned architecture.

	## Repository layout

	```
	README.md
	experiments/ 179 exploratory training runs (early sweeps, ablations, smoke runs)
	viz-data/
	experiments.json merged ablation curves used by the visualizer
	experiments-*.json per-run curve files behind that merge
	policy-mlp.{json,pt} policy-architecture comparison runs
	policy-transformer.{json,pt}
	q1-supervised/ supervised training runs and their evaluations
	q1-rl/ RL training runs at the 25M budget and their evaluations
	q1-eval/ aggregated Q1 tables (rl.json, supervised.json, rl-5m.json)
	q2/ 54 main-grid runs plus the goal-bonus extension (162 total)
	q3/ size-generalization runs and evaluations
	```

	File counts, excluding logs: `experiments/` 537, `q1-supervised/` 54, `q1-rl/` 24,
	`q1-eval/` 15, `q2/` 327, `q3/` 30.

	## Experiment details

	### Q1: cross-paradigm comparison (`q1-rl/`, `q1-supervised/`, `q1-eval/`)

	\| Arm \| Model \| Parameters \| Paired with \|
	\|---\|---\|---:\|---\|
	\| RL \| LSTM policy \| 183,081 \| supervised small \|
	\| RL \| Transformer policy \| 531,202 \| supervised large \|
	\| Supervised \| small sequence model \| 185,192 \| RL LSTM \|
	\| Supervised \| large sequence model (d_model 72, 7 layers, 8 heads, vocab 113, max sequence 1024) \| 532,152 \| RL Transformer \|

	Each arm trains with seeds 42, 43, and 44. The RL checkpoints are named
	`q1-25m-shaping-beta1-seed.pt` (LSTM) and `q1-25m-policy-transformer-seed.pt`. The
	supervised checkpoints are named `q1-soft-kl-{small,large}-train20000-seed*.pt`.

	Three frozen 1,000-graph suites test every checkpoint. Each suite is pinned by SHA-256,
	and every result row stores the hash in `suite_sha256`.

	\| Suite \| Node count range \|
	\|---\|---\|
	\| `train-scale` \| 16 to 32 \|
	\| `near-ood` \| 33 to 48 \|
	\| `far-ood` \| 64 to 96 \|

	Each checkpoint is evaluated with greedy and sampled decoding under a step budget of
	`4n`. That gives 180 fixed-suite conditions: 72 RL and 108 supervised.

	### Q2: shaping phase diagram (`q2/`)

	The main grid trains 54 five-million-step LSTM policies. It varies four factors:

	- reward mode: graded Δ (`shaping-beta1`), the β = 0 control (`shaping-sparse`), and a
	binary backward penalty (`shaping-binary`);
	- rollout horizon: `4n`, `2n`, and `1p25n` (1.25n);
	- graph regime: `small` (fixed n = 8 to 16) and `cold` (cold-start n = 32 to 64);
	- seeds 42, 43, and 44.

	The extension repeats the grid at goal bonuses of 1 and 0, which gives 162 runs. Every
	run uses the Muon optimizer at learning rate 0.015 with 1,024 parallel environments.

	Run names follow `q2-{regime}-{horizon}-g{goal_bonus}-{mode}-seed{seed}`, for example
	`q2-cold-1p25n-g0-shaping-beta1-seed42`. Each run has a `.json` curve file and a `.pt`
	checkpoint. The files `grid-manifest.json`, `grid-g0-manifest.json`, and
	`grid-g1-manifest.json` list every run with its final success rate.

	### Q3: size generalization (`q3/`)

	Nine five-million-step policies (MLP, LSTM, and Transformer, three seeds each) train on
	graphs up to n = 32. They are evaluated on n = 32, 48, 96, 192, 384, and 768 with 1,000
	graphs per condition, greedy and sampled decoding, and suite seed 20260726. The
	checkpoints are `q3-policy-mlp-seed.pt`, `q3-policy-transformer-seed.pt`, and
	`q3-shaping-beta1-seed*.pt` (the LSTM).

	### Exploratory runs (`experiments/`)

	This folder holds the runs from early in the project: the first ablation sweeps behind
	the visualizer and several smoke and reproducibility runs. Each run has a directory named
	by a numeric run id (`178120009848`) and a sibling final policy file
	(`178120009848.pt`). Inside the directory, PufferLib writes intermediate checkpoints
	(`model_000025.pt`) and the optimizer state (`trainer_state.pt`). These runs use
	different settings from the paper runs. The paper results come from `viz-data/`.

	## File formats

	Training curve files (`q2/.json`, `q3/experiments-.json`, `viz-data/experiments*.json`)
	hold `name`, `spec` (environment settings and recurrent wrapper), `n_params`, `seed`,
	`tag`, `artifact_stem`, `steps`, `num_envs`, and `curve`. Each `curve` entry records
	`agent_steps`, `epoch`, `SPS` (steps per second), `uptime`, and the PPO loss statistics
	(`losses/policy_loss`, `losses/value_loss`, `losses/entropy`,
	`losses/explained_variance`, `losses/approx_kl`).

	Evaluation files (`eval-*.json`) hold `config`, `runs`, and `summary`. Each row in
	`runs` describes one checkpoint on one suite and decoding mode:

	\| Field \| Meaning \|
	\|---\|---\|
	\| `episodes`, `successes`, `success_rate` \| episodes run and how many reached the target \|
	\| `episode_length` \| mean steps per episode \|
	\| `opt_gap` \| mean path cost of successful episodes divided by the optimal cost \|
	\| `backward_rate` \| fraction of moves that increase φ \|
	\| `two_cycle_rate`, `two_cycle_episode_rate` \| share of moves in A→B→A cycles, and share of episodes containing one \|
	\| `invalid_rate` \| fraction of masked-invalid actions (0.0 everywhere) \|
	\| `paradigm`, `architecture`, `training_budget`, `training_steps`, `train_seed` \| which model produced the row \|
	\| `suite`, `suite_sha256`, `n_min`, `n_max`, `decoding` \| the evaluation conditions \|
	\| `checkpoint`, `n_params` \| source checkpoint file and its parameter count \|

	Supervised run files (`q1-supervised/q1-soft-kl-*.json`) hold the training
	configuration (`variant`, `size`, `seed`, `steps`, `batch_size`, `tau`, `model`), the
	final loss, a 200-point loss `curve`, and `captures`, a list of integer checkpoint
	steps.

	Checkpoints (`.pt`) are PyTorch files. `train.py eval --load-model-path <file>` in
	the GitHub repository loads the RL checkpoints, and the supervised scripts in the same
	repository load the supervised ones.

	## Loading a file

	```python
	from huggingface_hub import hf_hub_download
	import json

	path = hf_hub_download(
	"lilcheaty/dijkwalk-experiments",
	"viz-data/q1-eval/rl.json",
	repo_type="dataset",
	)
	rows = json.load(open(path))["runs"]
	far = [r for r in rows if r["suite"] == "far-ood" and r["decoding"] == "sampled"]
	print(sum(r["success_rate"] for r in far) / len(far))
	```

	## Reproducing the runs

	Clone the GitHub repository and follow its `README.md`. It covers setup, `train.py`, the
	`scripts/q1_suite` verifier, and the per-question scripts under `scripts/`. The seed
	controls Python, NumPy, PyTorch, PufferLib, graph generation, policy initialization, and
	action sampling. Same-seed reruns produce tensor-identical checkpoints and identical
	non-timing curves. Every seed appears in its filename, so concurrent runs never
	overwrite each other.

	## Caveats

	- Greedy policies fall into two-cycles, so the headline numbers use sampled decoding.
	Greedy numbers are listed next to them where the paper reports both.
	- The Q1 comparison matches compute and parameters closely. It does not separate the
	effect of the training signal from every optimizer and data-distribution difference
	between the two paradigms.
	- The Q2 result is a null against a predeclared 15-point gate. The strongest cells show an
	8 to 12 point advantage for graded shaping.
	- The Q1 runs trained on a remote GPU box with the official CUDA 12.6 PyTorch wheel.
	`paper/EXPERIMENT-SUMMARY.md` in the GitHub repository lists every operational
	deviation.

	## Citation

	No formal citation exists yet. Cite the GitHub repository:
	<https://github.com/safzanpirani/dijkwalk>.