Datasets:

neilkale
/

WeightProgramBench

---
pretty_name: WeightProgramBench
language:
- en
task_categories:
- text-generation
size_categories:
- n<1K
tags:
- reinforcement-learning
- weight-space-programming
- games
- benchmark
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train.jsonl
  - split: test
    path: data/test.jsonl
---
# WeightProgramBench

Write the weights of a small game-playing neural network in one response,
without tools. Each task provides the game rules, observation layout, game
source, and network format. A CPU scorer reads numeric tensor assignments and
plays the resulting policy; it never executes model-written code or trains the
submitted network. Reinforcement learning can train the language model between
submissions.

This dataset preserves the expanded MinAtar Synth v4 corpus: **317 training
games and five held-out original MinAtar games**. It contains task prompts,
game implementations, the frozen scorer, and source attribution. It does not
contain reference solutions, model weights, or model-generated trajectories.

## Splits

| Split | Games | Family |
| --- | ---: | --- |
| Train | 51 | Atari-style synthetic Python conversions |
| Train | 266 | Crisp-inspired synthetic Python conversions |
| Test | 5 | Original MinAtar: Asterix, Breakout, Freeway, Seaquest, Space Invaders |

Training environments are compact Python adaptations, not Atari ROM emulation
or native Crisp gameplay. All use `10 × 10 × 6` binary observations. The five
original MinAtar games have their observation channels mapped into the same
six-channel input. The split holds out game identities; it does not establish
that every test mechanic is absent from training.

## Load the tasks

```python
from datasets import load_dataset
tasks = load_dataset("neilkale/WeightProgramBench")
print(len(tasks["train"]), len(tasks["test"]))  # 317, 5
task = tasks["test"][0]
messages = [
    {"role": "system", "content": task["system_prompt"]},
    {"role": "user", "content": task["prompt"]},
]
```

Each row preserves the original fields `name`, `split`, `game`, `source`,
`prompt`, `system_prompt`, and `episodes`. Additional columns are:

- `task_id`: zero-based index in the original 322-row task file. These IDs are
  not renumbered within splits.
- `family`: `atari_synthetic`, `crisp_synthetic`, or `minatar_original`.
- `upstream_source_url` and `upstream_revision`: implementation provenance.
- `native_source_url`: pinned native Crisp source, where applicable.

For reproducible experiments, pin the same dataset commit using `revision=`
when loading tasks and downloading runtime files.

## Policy and scoring

Every task uses a **600 → 32 → 32 → 6** network with **20,486 float32
parameters**, two tanh hidden layers, and softmax-sampled actions. All parameters
start at zero. The model supplies numeric tensor assignments in a fenced
`edits` block, following the task's format. The scorer validates assignments
with Python's AST and literal parser; it does not execute the response as Python.

Each submitted policy plays **1,000 episodes**:

- Environment seed: `1729 + episode_index`, covering `1729–2728`.
- Independent action RNG seed: `7919 + episode_index`, covering `7919–8918`.
- Sticky-action probability: `0.1`.
- Episode limit: termination or **10,000 actions**.
- Original MinAtar difficulty ramping: disabled.

Seeds are fixed across games and submissions. The reward is
`clip(mean_game_score, 0, game_score_cap) / game_score_cap`. Each synthetic game
declares its own cap. Original MinAtar caps are 1,000, except Freeway's cap of
100. These scales do not make games equally difficult. Invalid submissions
receive zero. Keep raw scores alongside normalized rewards when comparing
policies.

The frozen runtime uses **NumPy 2.3.4** and **MinAtar 1.0.15**. Policy inference
and replay run on CPU. One policy's 1,000 episodes are one language-model
sample, not 1,000 independent model generations.

## Score a saved response locally

Install the replay dependencies; installing MinAtar without dependencies avoids
adding optional visualization and training packages:

```bash
python -m pip install huggingface_hub 'numpy==2.3.4'
python -m pip install --no-deps 'MinAtar==1.0.15'
```

Save the model's complete response, including its `edits` block, in `answer.txt`.
Then evaluate it against the matching game:

```python
import json
from pathlib import Path
import sys
from huggingface_hub import snapshot_download
snapshot = Path(snapshot_download("neilkale/WeightProgramBench", repo_type="dataset"))
runtime = snapshot / "runtime"
sys.path.insert(0, str(runtime))
from verify import apply_edits, evaluate, score_cap
tasks = [json.loads(line) for line in (runtime / "tasks.jsonl").read_text().splitlines()]
task = next(task for task in tasks if task["game"] == "breakout" and task["source"] == "original")
answer = Path("answer.txt").read_text()
weights, edit_count = apply_edits(answer)
raw_score, mean_episode_length = evaluate(task["game"], task["source"], weights, task["episodes"])
cap = score_cap(task["game"], task["source"])
reward = min(max(raw_score, 0.0), cap) / cap
print({"raw_score": raw_score, "reward": reward, "mean_episode_length": mean_episode_length})
```

This example raises on malformed responses so local debugging is explicit.
For the benchmark's invalid-submission handling, use
`verify.grade_answer(game, source, answer, episodes)`, which returns a reward
and grading metadata. Full 1,000-episode replay can take several minutes,
depending on the game and CPU.

The Trajectory integration lives in the
[WeightProgramBench cookbook PR](https://github.com/Trajectorylabs/trajectory-cookbook/pull/104).
Model inference and training are separate from the local scorer.

## Files and integrity

- `data/train.jsonl`, `data/test.jsonl`: Hugging Face task splits with provenance
  columns added.
- `runtime/tasks.jsonl`: byte-identical frozen task records in their original
  order, without added columns.
- `runtime/minatar_synth/games/`: the 317 frozen Python training environments.
- `runtime/verify.py`: frozen policy parser and CPU scorer.
- `runtime/source.json`: SHA-256 digests for the original task file, scorer,
  and all 317 game files.
- `TASK_ORIGINS.json`: per-game source mappings, pinned revisions, and prompt
  and implementation digests.
- `THIRD_PARTY_NOTICES.md`, `runtime/NOTICE.txt`, and `runtime/LICENSE-*`:
  credits and applicable upstream notices.

Synthetic source revision: `4038830175c4201ca10e004ed4441985f2acddf2`.
Frozen task-file SHA-256:
`cc2d728fc3c820f217ecf43a4fdc0c9e2a5e292fcdd8b4afb0cb1d34774691e6`.

## Credits and licensing

The weight-space programming setup follows
[Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab's experiments](https://rikiyat.github.io/blog/weight-space-programming/),
particularly Experiment 5. The expanded training environments come from
[Trajectory Labs, Jerry Chan, and contributors to MinAtar Synth](https://github.com/Trajectorylabs/minatar-synth/tree/4038830175c4201ca10e004ed4441985f2acddf2).
Crisp game designs and sources are credited to **ABA Games** and contributors,
and the portable SDL/C versions to **Joyrider3774** and contributors.
Original **MinAtar** is by **Kenny Young and Tian Tian**.

Licensing differs by component: original MinAtar source is GPL-3.0, the cited
native Crisp source collections carry MIT notices, and the original experiment's
prompt/log materials are attributed under CC BY 4.0. The pinned MinAtar Synth
repository does not declare a license for its converted implementations. This
dataset does not assert a blanket license for those files. See
[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for the exact scopes and source
links; the original MinAtar source embedded in prompts retains its GPL scope.

	---
	pretty_name: WeightProgramBench
	language:
	- en
	task_categories:
	- text-generation
	size_categories:
	- n<1K
	tags:
	- reinforcement-learning
	- weight-space-programming
	- games
	- benchmark
	configs:
	- config_name: default
	data_files:
	- split: train
	path: data/train.jsonl
	- split: test
	path: data/test.jsonl
	---

	# WeightProgramBench

	Write the weights of a small game-playing neural network in one response,
	without tools. Each task provides the game rules, observation layout, game
	source, and network format. A CPU scorer reads numeric tensor assignments and
	plays the resulting policy; it never executes model-written code or trains the
	submitted network. Reinforcement learning can train the language model between
	submissions.

	This dataset preserves the expanded MinAtar Synth v4 corpus: **317 training
	games and five held-out original MinAtar games**. It contains task prompts,
	game implementations, the frozen scorer, and source attribution. It does not
	contain reference solutions, model weights, or model-generated trajectories.

	## Splits

	\| Split \| Games \| Family \|
	\| --- \| ---: \| --- \|
	\| Train \| 51 \| Atari-style synthetic Python conversions \|
	\| Train \| 266 \| Crisp-inspired synthetic Python conversions \|
	\| Test \| 5 \| Original MinAtar: Asterix, Breakout, Freeway, Seaquest, Space Invaders \|

	Training environments are compact Python adaptations, not Atari ROM emulation
	or native Crisp gameplay. All use `10 × 10 × 6` binary observations. The five
	original MinAtar games have their observation channels mapped into the same
	six-channel input. The split holds out game identities; it does not establish
	that every test mechanic is absent from training.

	## Load the tasks

	```python
	from datasets import load_dataset

	tasks = load_dataset("neilkale/WeightProgramBench")
	print(len(tasks["train"]), len(tasks["test"])) # 317, 5
	task = tasks["test"][0]
	messages = [
	{"role": "system", "content": task["system_prompt"]},
	{"role": "user", "content": task["prompt"]},
	]
	```

	Each row preserves the original fields `name`, `split`, `game`, `source`,
	`prompt`, `system_prompt`, and `episodes`. Additional columns are:

	- `task_id`: zero-based index in the original 322-row task file. These IDs are
	not renumbered within splits.
	- `family`: `atari_synthetic`, `crisp_synthetic`, or `minatar_original`.
	- `upstream_source_url` and `upstream_revision`: implementation provenance.
	- `native_source_url`: pinned native Crisp source, where applicable.

	For reproducible experiments, pin the same dataset commit using `revision=`
	when loading tasks and downloading runtime files.

	## Policy and scoring

	Every task uses a 600 → 32 → 32 → 6 network with **20,486 float32
	parameters**, two tanh hidden layers, and softmax-sampled actions. All parameters
	start at zero. The model supplies numeric tensor assignments in a fenced
	`edits` block, following the task's format. The scorer validates assignments
	with Python's AST and literal parser; it does not execute the response as Python.

	Each submitted policy plays 1,000 episodes:

	- Environment seed: `1729 + episode_index`, covering `1729–2728`.
	- Independent action RNG seed: `7919 + episode_index`, covering `7919–8918`.
	- Sticky-action probability: `0.1`.
	- Episode limit: termination or 10,000 actions.
	- Original MinAtar difficulty ramping: disabled.

	Seeds are fixed across games and submissions. The reward is
	`clip(mean_game_score, 0, game_score_cap) / game_score_cap`. Each synthetic game
	declares its own cap. Original MinAtar caps are 1,000, except Freeway's cap of
	100. These scales do not make games equally difficult. Invalid submissions
	receive zero. Keep raw scores alongside normalized rewards when comparing
	policies.

	The frozen runtime uses NumPy 2.3.4 and MinAtar 1.0.15. Policy inference
	and replay run on CPU. One policy's 1,000 episodes are one language-model
	sample, not 1,000 independent model generations.

	## Score a saved response locally

	Install the replay dependencies; installing MinAtar without dependencies avoids
	adding optional visualization and training packages:

	```bash
	python -m pip install huggingface_hub 'numpy==2.3.4'
	python -m pip install --no-deps 'MinAtar==1.0.15'
	```

	Save the model's complete response, including its `edits` block, in `answer.txt`.
	Then evaluate it against the matching game:

	```python
	import json
	from pathlib import Path
	import sys
	from huggingface_hub import snapshot_download

	snapshot = Path(snapshot_download("neilkale/WeightProgramBench", repo_type="dataset"))
	runtime = snapshot / "runtime"
	sys.path.insert(0, str(runtime))
	from verify import apply_edits, evaluate, score_cap

	tasks = [json.loads(line) for line in (runtime / "tasks.jsonl").read_text().splitlines()]
	task = next(task for task in tasks if task["game"] == "breakout" and task["source"] == "original")
	answer = Path("answer.txt").read_text()
	weights, edit_count = apply_edits(answer)
	raw_score, mean_episode_length = evaluate(task["game"], task["source"], weights, task["episodes"])
	cap = score_cap(task["game"], task["source"])
	reward = min(max(raw_score, 0.0), cap) / cap
	print({"raw_score": raw_score, "reward": reward, "mean_episode_length": mean_episode_length})
	```

	This example raises on malformed responses so local debugging is explicit.
	For the benchmark's invalid-submission handling, use
	`verify.grade_answer(game, source, answer, episodes)`, which returns a reward
	and grading metadata. Full 1,000-episode replay can take several minutes,
	depending on the game and CPU.

	The Trajectory integration lives in the
	[WeightProgramBench cookbook PR](https://github.com/Trajectorylabs/trajectory-cookbook/pull/104).
	Model inference and training are separate from the local scorer.

	## Files and integrity

	- `data/train.jsonl`, `data/test.jsonl`: Hugging Face task splits with provenance
	columns added.
	- `runtime/tasks.jsonl`: byte-identical frozen task records in their original
	order, without added columns.
	- `runtime/minatar_synth/games/`: the 317 frozen Python training environments.
	- `runtime/verify.py`: frozen policy parser and CPU scorer.
	- `runtime/source.json`: SHA-256 digests for the original task file, scorer,
	and all 317 game files.
	- `TASK_ORIGINS.json`: per-game source mappings, pinned revisions, and prompt
	and implementation digests.
	- `THIRD_PARTY_NOTICES.md`, `runtime/NOTICE.txt`, and `runtime/LICENSE-*`:
	credits and applicable upstream notices.

	Synthetic source revision: `4038830175c4201ca10e004ed4441985f2acddf2`.
	Frozen task-file SHA-256:
	`cc2d728fc3c820f217ecf43a4fdc0c9e2a5e292fcdd8b4afb0cb1d34774691e6`.

	## Credits and licensing

	The weight-space programming setup follows
	[Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab's experiments](https://rikiyat.github.io/blog/weight-space-programming/),
	particularly Experiment 5. The expanded training environments come from
	[Trajectory Labs, Jerry Chan, and contributors to MinAtar Synth](https://github.com/Trajectorylabs/minatar-synth/tree/4038830175c4201ca10e004ed4441985f2acddf2).
	Crisp game designs and sources are credited to ABA Games and contributors,
	and the portable SDL/C versions to Joyrider3774 and contributors.
	Original MinAtar is by Kenny Young and Tian Tian.

	Licensing differs by component: original MinAtar source is GPL-3.0, the cited
	native Crisp source collections carry MIT notices, and the original experiment's
	prompt/log materials are attributed under CC BY 4.0. The pinned MinAtar Synth
	repository does not declare a license for its converted implementations. This
	dataset does not assert a blanket license for those files. See
	[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for the exact scopes and source
	links; the original MinAtar source embedded in prompts retains its GPL scope.