odats/breakout-ram4-1024

Breakout RAM4: 1,024 training programs and four test splits

Full frozen-action-program trajectories for analogy and dynamics modeling in ALE Breakout. Each state contains four consecutive 128-byte RAM observations (uint8, shape [4,128]). There are 2,048 unique programs, 20,480 replays, and 7,323,028 program transitions, excluding warm-up. Generation seed: 20260915.

Splits

Archive / split	Programs	Replays/program	Actual length range	Mean length
train.zip	1,024	16	256–438	295.02
random_matched.zip	256	4	256–511	382.22
random_long.zip	256	4	514–1,311	814.32
policy_matched.zip	256	4	256–512	381.41
policy_long.zip	256	4	516–1,311	853.17

Each split is a ZIP archive containing compressed NumPy program_NNNN.npz files. ZIP itself uses stored entries to preserve the already-compressed NPZ contents. snapshots.zip contains pre/post-warm-up ALE system snapshots. Metadata and checksums are available separately, so they can be inspected without downloading all trajectories. No Atari ROM binary is included. Emulator state files require a compatible ALE version and an independently available matching Breakout ROM. No license is asserted for third-party game content or emulator state contents.

Download and load

Install numpy and huggingface_hub. Replace OWNER with this repository's owner:

import io, zipfile
import numpy as np
from huggingface_hub import hf_hub_download

archive = hf_hub_download("odats/breakout-ram4-1024", "train.zip", repo_type="dataset")
with zipfile.ZipFile(archive) as z:
    with np.load(io.BytesIO(z.read("train/program_0000.npz")), allow_pickle=False) as f:
        data = {key: f[key] for key in f.files}

A, B = data["ram_in"][0], data["ram_out"][0]
C, D = data["ram_in"][1], data["ram_out"][1]
assert A.shape == B.shape == C.shape == D.shape == (4, 128)

# Extract an arbitrary 32-action substring from replay 0.
t = 10
actions = data["actions"][t:t+32]             # [32]
observations = data["states"][0, t:t+33]     # [33,4,128]
rewards = data["rewards"][0, t:t+32]         # [32]

load_example.py provides the same loading pattern with SHA-256 verification. Pass the release commit hash as revision for immutable downloads. To fetch the entire repository, use snapshot_download(..., repo_type="dataset"), verify SHA256SUMS, and extract the six archives into one directory. The resulting layout matches the original generator and audit tools.

Per-program arrays

Let R be 16 for training or 4 for tests, and L be program length.

Key	Shape	Meaning
actions	[L]	One immutable tape shared across replays
ram	[R,L+1,128]	Initial raw RAM plus RAM after every action
states	[R,L+1,4,128]	Causal four-frame histories at every step
ram_in, ram_out	[R,4,128]	Initial and final histories
initial_history	[R,4,128]	History before the program starts
rewards, terminal	[R,L]	Per-action reward and game-over flags
lives	[R,L+1]	Lives at each observation
warmup_actions	[3]	Three FIRE actions outside the program
warmup_rewards	[R,3]	Rewards during history construction
warmup_lives	[R,4]	Lives during history construction
start_ids, held_out	[R]	Split-scoped start IDs and evaluation flags

Policy splits also contain policy_source_initial (serialized ALE state bytes), policy_source_ram ([L+1,128]) and policy_source_rewards ([L]). Program provenance, length multiplier and event statistics are in programs.jsonl. state_pool.json maps start IDs within each split to snapshot paths and seeds.

Protocol

• ALE 0.12.1; one emulator frame per action; sticky probability zero.
• Action indices: 0 NOOP, 1 FIRE, 2 RIGHT, 3 LEFT.
• Three FIRE warm-up actions establish a causal initial history before tape replay.
• Each tape is replayed exactly, without policy decisions during replay.
• Life loss is allowed. Game-over replays are rejected, including terminal endpoints. No accepted replay is reset, shortened or terminal-padded.
• Training uses 16 shared starts. Replay indices 0–14 are for optimization and index 15 is held-out-state validation. Do not train on index 15 or its substrings.
• Tests select four surviving starts from independent 128-start banks. For analogy evaluation, rotate the query and use the other three pairs as demonstrations.
• Random programs use IID uniform actions. Policy programs come from a RAM ball-following heuristic with FIRE when no ball is visible; it is not a learned policy or a guaranteed board-clearing controller. Source traces are retained.
• Long candidates use 2L, 3L or 4L, where L is sampled from 256–512. Survival filtering affects the accepted distribution. The accepted 2×/3×/4× counts are 168/77/11 for random long and 163/63/30 for policy long.

Validation and limitations

All 20,480 saved replays were independently reproduced in a verifier emulator, including raw RAM, rewards, lives, terminal flags, warm-up, snapshots and stacked histories. audit.json records independent serialized contract checks. Training meets the original pilot's motion/event/diversity gates: at least 97.70% program pair distinction at each shared start and 12 distinct effects across starts per program. All 465,920 training three-demonstration subsets have distinct inputs; this does not prove arbitrary action programs are inferable from demonstrations.

No validation/test endpoint pair duplicates a training pair. Individual endpoint history overlaps remain: 5 in held-out-state validation, 2 in random matched, 2 in random long, and 0 in policy tests. Intermediate-history overlaps and action near-duplicates are not exhaustively audited. Keep all substrings from a replay in its original split.

The nominal matched range is the same as training, but survival filtering skews training shorter (mean 295 versus 381–382 frames in matched tests). Accepted long lengths reach 1,311 frames, not the candidate maximum of 2,048. Test consequence diversity is reported rather than gated; some policy-long programs have identical common-prefix effect signatures across their four starts.

Raw byte accuracy is dominated by unchanged bytes. Report copy-input baselines, changed-byte and named gameplay-field accuracy, and exact four-frame accuracy. Bitmap-change events are proxies rather than decoded brick counts. Four RAM frames give motion evidence but do not establish a complete Markov state.

Reproduction

generation/ contains the generator, independent audit, imported recipe helpers, and dependency versions. Run generate_benchmark.py --out NEW_DIRECTORY --workers 4 from an environment with the recorded ALE version and ROM hash. Inspect manifest.json for environment settings, seed, ROM hash and generator hash. The original workflow is based on https://github.com/odats/arc_erd and the repository's Breakout frozen-program recipe. No model checkpoint is included.