Egocentric multi-camera trajectory data from a Robotic Mobile Fulfillment System (RMFS) warehouse simulator, collected to train a World Model (VAE → MDN-RNN → CMA-ES controller, after Ha & Schmidhuber 2018) that acts as a per-robot speed governor.

Research project at NTUST, Prof. Chou's CITI lab, extending the RAWSim-O discrete-event simulator.

The controller does not choose where a robot goes. A* owns routing. The controller chooses how fast the robot travels along the route A* already picked — a binary speed_override flag plus a discrete signed acceleration.

Status — read this before using the data

No controller in this project has a validated win over A*. The validated result is throughput parity without collapse: 404.3 items against A*'s 423.0 (95.6%), up from a collapsed 22.0. At λ=0 the controller is strictly dominated by A*.

An earlier headline result (−37.6% collisions, −33.1% energy) was retracted on 2026-08-04: the apparent gain was robots locking up motionless at replenishment stations, not yielding behaviour. The data behind that run is not in this repository.

This corpus is published as the evidence base, not as a benchmark with a known-good solution.

What is here

Raw episode corpora — `raw/`

Each episode is a directory of 32 bot_*.npz (one per robot) plus one map.npz. All three timesteps cover the same 500 s of simulated warehouse time.

path	planner	timestep	steps/ep	episodes	collisions
`raw/halfstep_0.5s/astar/`	AgentAStar (decentralized)	0.5 s	1000	60	present (~3.7% of steps)
`raw/halfstep_0.5s/far/`	FAR (centralized MAPF)	0.5 s	1000	10	exactly 0
`raw/surround360_1.0s/astar/`	AgentAStar	1.0 s	500	30	present
`raw/surround360_1.0s/far/`	FAR	1.0 s	500	30	exactly 0
`raw/quarterstep_0.25s/astar/`	AgentAStar	0.25 s	2000	60	present
`raw/quarterstep_0.25s/far/`	FAR	0.25 s	2000	10	exactly 0

The astar/far contrast is the point of the corpus. A* is decentralized and has real collisions; FAR is centralized and is collision-free by construction. A speed layer needs both.

A recorded caveat, not withdrawn: a centralized planner avoids collisions by rerouting, not braking, which arguably erases the very contrast a speed layer needs. FAR was added deliberately anyway — to widen the range of routing behaviour, not to imitate braking.

Latent caches — `z_cache/`

Pre-encoded 256-dim latents, ready for MDN-RNN / controller training without re-running the VAE. All encoded with the 0.5 s VAE (vae_surround05_100ep, shared per-view encoder, 64 dims per camera concatenated view-major: z[0:64] front, [64:128] left, [128:192] back, [192:256] right).

path	reward target	trajectories
`z_cache/gamma05_wstall020/`	`rewards_gamma0.5_wstall0.20`	838
`z_cache/bal_nostall/`	`rewards_bal_nostall`	838
`z_cache/pick8_nostall/`	`rewards_pick8_nostall`	838
`z_cache/graded/`	`rewards_graded` (graded stall penalty)	838

838 = 70 episodes × 12 robots, minus 2 (far episode 5, bots 29 and 31). The 12 robots are ids 0, 2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 31.

Episode numbering in the caches: 0–59 astar, 60–69 far (far is offset by +60, while both raw corpora number from 0000). A wrong offset silently attaches another episode's rewards — same shape, same dtype, no error.

Legacy — `z_legacy/speedgov_64dim/`

3,840 trajectories of 64-dim single-camera latents from the earlier astar-speedrandom collection (120 episodes, 1.0 s). Not compatible with the 4-camera models. Kept because it is the only surviving artifact of the one collection that ever randomized the speed axes — every other corpus here records the constant defer action [4, 1, 2].

Episode indices 1008–1225, not contiguous (7 gaps from a 16-worker OOM during collection). Do not assume contiguity when globbing.

Model weights — `checkpoints/`

VAEs, MDN-RNNs, controllers, gate results and training curves. Included here for provenance alongside the data they were trained on.

File schema

`bot_*.npz` (per robot, per episode)

key	shape	dtype	notes
`obs`	`(T, 4, 96, 96, 3)`	uint8	4 cameras: yaw 0/90/180/270, 120° FOV, 30° overlap, common optical centre
`actions`	`(T, 3)`	int32	`[direction, speed_override, signed_accel]`
`realized_signed_accel_idx`	`(T,)`	int32	use this, not `actions[:,2]` — see below
`rewards`	`(T,)`	float32	collection-time reward
`collisions`	`(T,)`	int32	per-step collision count
`positions`	`(T, 3)`	float32	x, y, orientation
`energy_e1`…`energy_e5`	`(T,)`	float32	four-component physics energy model + pod lift
`energy_support`, `energy_total`	`(T,)`	float32
`command_distance`	`(T,)`	int32
`dones`	`(T,)`	bool
`episode_seed`, `n_max`, `black_frames_replaced`	scalar

`map.npz` (one per episode)

key	shape	dtype	notes
`frames`	`(T, 256, 256, 3)`	uint8	top-down whole-map RGB, shared across all robots
`bounds`	`(4,)`	float64	world-coordinate extent

Used by the collision-validation and visualisation scripts only — the training pipeline never reads it. It is ~43% of the raw bytes here; skip map.npz if you only want to train.

`z_cache//episode__bot_*.npz`

Same scalar fields as bot_*.npz, with obs replaced by z (T, 256) float32, plus signed_accel, speed_override, observation_weights, and the reward variant for that cache.

Three traps that cost real time

1. Use realized_signed_accel_idx, not the commanded action. In A*/baseline collection the chosen signed_accel is a constant — Python always sends the deferred action. Any ablation that permutes it is a mathematical no-op, and will appear to fail for reasons that have nothing to do with your model. Rebuilding the action channel from the realized index flipped a long-failing shuffle ablation to a clean pass with no re-collection.

2. Reward numbers do not transfer across timestep. STEP_COST, W_STALL and GAMMA are all per-step. The same 500 s episode totals −39.0 at 0.5 s and −125.5 at 0.25 s under identical weights. A reward figure quoted without its dt is meaningless, and every naive baseline must be recomputed when dt changes.

3. Finer sampling does not extend the predictable horizon. Lag-1 latent drift is 60.2% at 1.0 s → 46.9% at 0.5 s → 41.9% at 0.25 s, but at matched elapsed time all three corpora agree within a point. The predictable window belongs to the warehouse, not the sampling rate — halving dt subdivides that window rather than lengthening it. The 0.25 s corpus is included for completeness; no result in the project rests on it.

Loading

import numpy as np, glob

# one robot's trajectory
d = np.load("raw/halfstep_0.5s/astar/episode_0000/bot_0.npz")
obs    = d["obs"]                          # (1000, 4, 96, 96, 3) uint8
accel  = d["realized_signed_accel_idx"]    # (1000,) int32  <- not d["actions"][:,2]

# pre-encoded latents, no VAE needed
z = np.load("z_cache/gamma05_wstall020/episode_0000_bot_0.npz")
print(z["z"].shape)                        # (1000, 256)

# glob rather than assuming contiguous indices
files = sorted(glob.glob("z_legacy/speedgov_64dim/episode_*_bot_*.npz"))

The four camera views are concatenated view-major in the latent, so a single-camera ablation is z[:, 0:64] — no re-encoding required.

Provenance and citation

Collected with collect_worldmodel_dataset.py against RAWSim-O's GymServer TCP bridge, instance jenkinsinstance1.xinst with jenkinssetting1_fastpick.xsett and jenkinsconfig_agentastar.xconf. Energy is the four-component physics model ported into the C# simulator; the MDN-RNN's energy target uses E1+E2+E3+E4 only — E5 (pod lift/lower) and support draw are routing-invariant and including them creates a perverse incentive to avoid completing tasks.

If you use this data, please cite the RAWSim-O simulator (Merschformann et al.) alongside this repository.

Downloads last month: -

Total file size:

80.9 GB

You need to agree to share your contact information to access this dataset

RMFS World Models — Speed Governor Corpora

Status — read this before using the data

What is here

Raw episode corpora — raw/

Latent caches — z_cache/

Legacy — z_legacy/speedgov_64dim/

Model weights — checkpoints/