mzxuan/real_world_data

Real-world manipulation demonstrations — common HDF5 interface

This release standardizes 1,000 episodes across five tasks for shared camera3, robot-state, timestamp, and language loading. There are 200 episodes per task: 100 clean and 25 each at clutter levels d1, d2, d3, and d4. Conditions are collection subsets, not predefined train/validation/test splits.

Four older tasks have been upgraded to the HDF5 interface of the newer three-cups task. The 200 three-cups HDF5 files, their instructions, and their JSON annotations are unchanged. Existing folder names retain _amir; canonical task IDs inside migrated HDF5 files do not.

The repository also contains historical put_book_in_box_amir archives. They are excluded from this release, migration, audit, and example reader. They remain untouched and must not be assumed to use the schema described here.

Tasks and instruction labels

Folder	Canonical HDF5 task	Language instruction	Episodes	Frames
put_mug_on_coaster_amir	put_mug_on_coaster	put the mug on a coaster	200	44,937
put_bowl_on_rack_amir	put_bowl_on_rack	put the bowl on a rack	200	46,180
put_cup_in_bowl_amir	put_cup_in_bowl	put the blue cup in the white bowl	200	43,368
stack_two_cubes_amir	stack_two_cubes	stack the two cubes	200	43,517
place_three_cups_in_bowls	place_three_cups_in_bowls	35 recorded instructions specifying cup/bowl colors and order	200	144,340
Total			1,000	322,342

Each task directory has a language_instructions.json catalog. Each old task has one user-defined instruction template used across all clutter levels. The three-cups task retains its 35 unique instructions; instructions can repeat across conditions. Cube order is deliberately unspecified for stack_two_cubes.

task is a stable identifier, not the command supplied to the model. Use the root language_instruction attribute for language conditioning. Do not derive instructions by replacing underscores in folder names.

Archive layout and downloading

The existing task/condition TAR layout is preserved; there are 25 archives for the five supported tasks, not one combined archive:

<task-folder>/
  language_instructions.json
  clean/<task-folder>_clean.tar
  d1/<task-folder>_d1.tar
  d2/<task-folder>_d2.tar
  d3/<task-folder>_d3.tar
  d4/<task-folder>_d4.tar

Each uncompressed TAR starts with data/<episode-number>/. Episode numbers restart within every task/condition. Use (task-folder, condition, episode) as the unique episode key. Do not extract different archives into the same directory without separating task and condition: their data/1, etc. overlap.

Typical episode contents:

data/1/
  episode1.hdf5
  meta.json
  intrinsics.json
  state.csv
  task_sequence.json
  camera1/*.png
  camera1_depth/*.png
  camera2/*.png
  camera2_depth/*.png
  camera3/*.png
  camera3_depth/*.png

All original camera folders and archive entries are retained. Only the 800 old HDF5 payloads were replaced; 800 task-sequence JSON files were added. The five existing three-cups TARs are reused byte-for-byte. Task instruction catalogs are separate files above the condition directories, not TAR members. release_manifest.json lists archive paths, sizes, SHA-256 checksums, and whether each archive was repackaged or reused. Old archive versions remain accessible through the repository's commit history.

Download just the required task/condition; pin a repository commit SHA for reproducible experiments:

from huggingface_hub import hf_hub_download

task = "put_mug_on_coaster_amir"
condition = "d1"
archive = hf_hub_download(
    repo_id="mzxuan/real_world_data",
    repo_type="dataset",
    filename=f"{task}/{condition}/{task}_{condition}.tar",
    revision="main",  # Replace with a commit SHA to pin a release.
)
print(archive)

Extract a downloaded archive into its own task/condition directory:

mkdir -p dataset/put_mug_on_coaster_amir/d1
tar -xf /path/to/put_mug_on_coaster_amir_d1.tar \
  -C dataset/put_mug_on_coaster_amir/d1 --strip-components=1

For HDF5-only training, camera PNG extraction is optional because images/depth are already embedded in each HDF5. With GNU tar you can extract only training files and their companions:

tar -xf /path/to/put_mug_on_coaster_amir_d1.tar \
  -C dataset/put_mug_on_coaster_amir/d1 --strip-components=1 --wildcards \
  'data/*/episode*.hdf5' 'data/*/meta.json' 'data/*/intrinsics.json' \
  'data/*/state.csv' 'data/*/task_sequence.json'

Download the task catalog separately if needed. Local extraction strips the data/ prefix; the reader below expects <root>/<task>/<condition>/<episode>/. These archives are not an automatically configured Hugging Face datasets table; use huggingface_hub for download and h5py for episode access.

HDF5 schema

Root hdf5_schema_version is integer 2; /task has schema_version 1. There are 40 common datasets. Old episodes have two extra datasets for migration provenance and annotation validity. Episode length T varies.

Observations and timeline

Path	Dtype	Shape	Meaning
/observations/images/camera{1,2,3}	uint8	[T,480,640,3]	RGB, HWC, raw 0–255 pixels
/observations/depth/camera{1,2,3}	uint16	[T,480,640]	Raw depth; apply that camera's depth_scale
/observations/tcp_pos	float32	[T,3]	TCP xyz in robot base, meters
/observations/tcp_quat	float32	[T,4]	TCP quaternion, xyzw order
/observations/joints	float32	[T,6]	Six recorded robot joint positions, radians
/observations/gripper_pos	float32	[T]	Raw recorded gripper signal, 0–255 scale
/observations/qpos	float32	[T,7]	Six joints followed by normalized gripper
/observations/state	float32	[T,14]	TCP xyz, quaternion xyzw, six joints, normalized gripper
/timestamps	float64	[T]	Recorded Unix timestamps, seconds
/frame_indices	int64	[T]	Sequential zero-based 0..T-1 indices

Precisely:

gripper_normalized = gripper_pos / 255.0
qpos = concatenate([joints, gripper_normalized[..., None]], axis=-1)
state = concatenate([tcp_pos, tcp_quat, joints,
                     gripper_normalized[..., None]], axis=-1)

Do not divide the final state/qpos component by 255 again. The gripper signal is not a width in meters or a ground-truth object-contact label. RGB and depth datasets use gzip compression with one-frame chunks. Other small arrays are uncompressed in this release. All three cameras are retained in HDF5, even though the primary training use here is camera3.

Root attributes and metadata

Root attributes: task, language_instruction, condition, episode_status, episode_success (Boolean), hdf5_schema_version, num_frames, num_cameras.

/task repeats task, instruction, condition, status, and success; adds clutter_level (0..4), schema_version=1, coordinate_frame="robot_base", units="m", quat_convention="xyzw", and recorded_at.

Scalar UTF-8 JSON datasets:

• /metadata/meta_json: original episode metadata. Old task names inside this source copy still contain _amir; use root task for the canonical ID.
• /metadata/intrinsics_json: original camera intrinsics.
• /task/task_sequence_json: same parsed task content as external task_sequence.json.
• /metadata/migration_json: old tasks only, containing migration profile, original/canonical task IDs, original HDF5 hash, instruction/success sources, and annotation-availability information.

Read scalar JSON with json.loads(f[path].asstr()[()]), and string arrays with f[path].asstr()[:]. Dataset dtype may display as object in NumPy for HDF5 variable-length UTF-8 strings; this does not mean pickled Python objects.

Calibration and depth

/camera_info/cameraN attributes contain serial, width, height, fx, fy, cx, cy, depth_scale, and distortion model. Its coeffs dataset is float64 [5]. Read per-episode values rather than hard-coding them.

depth_m = depth_raw.astype("float32") * f["camera_info/camera3"].attrs["depth_scale"]
depth_valid = depth_raw != 0

The camera3 eye-to-hand calibration is supplied separately under camera_calibration/camera3_eye_to_hand. The published result_4/camera3_to_base_20260909_145032.npy is T_base_camera3, a 4×4 transform taking homogeneous camera3 points into the robot base: p_base = T_base_camera3 @ p_camera3. Do not invert it merely because some consumer calls a configuration field T_cam_base. Confirm the camera mount/calibration applicability before geometric use or deployment; a calibration artifact's presence is not proof of per-episode extrinsic accuracy.

Temporal annotations: recorded versus unavailable

Path	Type/shape	Three-cups	Four old tasks
/frame_annotations/chunk_index	int64 [T]	Recorded values, including idle -1	All -1
/frame_annotations/phase	UTF-8 [T]	Recorded phase	All "unknown"
/frame_annotations/active_target_id	UTF-8 [T]	Recorded object ID	Empty strings
/frame_annotations/active_destination_id	UTF-8 [T]	Recorded object ID	Empty strings
/frame_annotations/annotation_valid	bool [T]	Dataset absent	All false
/task/steps/*	1-D arrays	Three recorded steps per episode	Length zero
/task/cup_order	UTF-8 array	Recorded cup-color order	Empty
/task/bowl_assignment/{cup_colors,bowl_colors}	UTF-8 arrays	Recorded mapping	Empty

Step fields are chunk_index (int64), target_id and destination_id (UTF-8), color_match and success (bool), and start_frame, grasp_frame, release_frame, completion_frame (int64), with corresponding *_ts (float64 seconds).

Reader rule: when annotation_valid exists, honor it. When absent in the existing three-cups schema, use recorded frame annotations normally. Do not derive validity from chunk_index != -1: a legitimate recorded idle frame can have chunk_index=-1.

The validity mask applies only to temporal labels. An old task's false mask does not mean its RGB, state, language, or demonstration is invalid. Empty step tables mean “not annotated,” not “no action occurred.” Old task JSONs explicitly mark missing objects, clutter-object identities, steps, frames, recording time, and seed as unavailable; three-cup-specific order/assignment fields are not applicable. An empty clutter-object list does not mean the scene was clean. Use condition/clutter_level.

Old recording time is JSON null and an empty HDF5 /task attribute. It was not replaced with migration time. Object poses in three-cups JSON may be human placement plans with measured_pose=null; do not treat planned poses as sensor-measured ground truth.

Success labels and provenance

All 800 old episodes have episode_success=true, episode_status="completed", and success_source="collection_policy". These are user-confirmed collection labels, not a new visual success audit. Their instruction source is user_defined_task_template. The three-cups task preserves its recorded episode and step labels. No labels were inferred from motion or images.

Known timing and source-data caveats

1. Step timestamp/frame offset in the unchanged three-cups data: all 2,400 start/grasp/release/completion event timestamps across 200 episodes match timestamps[event_frame - 1], not timestamps[event_frame]. HDF5 step tables agree with task JSON, and frame-annotation arrays agree with CSV. Do not silently treat stored step indices as equivalent to the zero-based /frame_indices. Resolve the collector convention before step supervision. The example helper can map event timestamps onto the actual timeline; it does not change stored annotations or invent old-task events.
2. Sampling is not perfectly fixed-rate. Typical intervals are about 0.05 seconds, but 639 episodes have a gap above 0.2 seconds. The largest observed gap is 0.740142822265625 seconds in stack_two_cubes_amir/clean/78. All timestamps are strictly increasing and match CSV. If time-based resampling is needed, define it explicitly in the training pipeline; no resampling was performed here.
3. Extra historical PNGs: eight cup-in-bowl d3 episodes contain additional unreferenced PNGs. Original TAR entries, including duplicate names, remain preserved. The HDF5/CSV timeline is authoritative. Never build training sequences by blindly globbing all PNGs or by relying on archive entry order.
4. Image preprocessing is a loader choice. Images are raw HWC RGB. Decide crop/resize, CHW conversion, and model normalization explicitly. RGB/state temporal alignment was checked against the stored timeline, not independently measured hardware exposure synchronization.

Shared data-loader example

Install h5py and numpy. See examples/read_hdf5.py for a tested reader that excludes book-in-box, opens files per call, and returns arrays without leaking open HDF5 handles across multiprocessing workers.

from examples.read_hdf5 import iter_episodes, episode_info, read_window

for path in iter_episodes("dataset"):
    info = episode_info(path)
    if info["num_frames"] < 8:
        continue
    sample = read_window(path, start=0, length=8, include_depth=True)
    # image: [8,480,640,3], state: [8,14], timestamp: [8]
    # task/language_instruction: strings
    # annotation_valid: [8], only controls temporal-label supervision
    print(sample["task"], sample["language_instruction"])

For training:

• Split by whole episode using the full task/condition/episode key. Avoid overlapping windows from the same episode across training and evaluation.
• Use fixed-length windows or explicit padding plus a separate padding mask. The annotation-validity mask is not a padding mask.
• Do not allow windows to cross episode boundaries. For contiguous windows, read_window rejects out-of-range requests rather than silently padding.
• Keep timestamps float64, or subtract episode start time before casting to lower precision; float32 Unix timestamps lose subsecond resolution.
• Load image/depth slices on demand. Do not materialize every episode or hold inherited h5py.File objects in forked workers. A per-worker handle cache is an optional optimization that must be explicitly managed and closed.
• Batch strings separately or tokenize them with the chosen model's tokenizer. Decide task/condition sampling weights: uniform frame sampling weights longer three-cups demonstrations more heavily than uniform episode/task sampling.
• Estimate normalization statistics on the training split only. Quaternions, raw gripper values, normalized gripper values, and meters/radians have different semantics; do not apply a single scale blindly.
• No /actions dataset exists. state, qpos, and consecutive differences are observations, not declared control commands. Action representation, target horizon, relative/absolute conventions, terminal-window handling, and any observation-derived targets must be decided and documented separately. This release does not invent actions or guarantee compatibility with an arbitrary policy-training framework without those choices.

Validation and release provenance

An independent audit checked every one of the 1,000 files: common paths, attribute/dataset types, dimensions, compression/chunk layout, CSV alignment, all robot-state values, JSON/catalog consistency, missing-label semantics, and shared-reader output. All 322,342 camera3 RGB frames and 322,342 depth frames were decoded without unreadable or entirely zero frames. All migrated camera3 chunks matched their original backups. A mixed batch containing all five tasks was also tested.

Cameras1/2 were decoded at first/middle/last frames of every episode during the independent audit; they were not fully decoded in that audit. The migration separately compared all original observation, calibration, and timestamp datasets against backups, including unchanged compression settings. Three-cups HDF5 and JSON baseline hashes were verified unchanged after migration.

Packaging preserves all unchanged original TAR bytes, replaces only each old HDF5 member, and adds task JSON companions. Each source TAR hash is checked against the pre-release Hub version, and each archived original HDF5 against its migration backup hash. Updated HDF5 metadata and new JSON companions are validated directly inside the replacement TARs before upload. The release manifest records resulting archive checksums.

See validation_summary.json and release_manifest.json. Local migration backups, temporary staging files, credentials, and internal logs are not published. No source PNGs were deleted, no folders renamed, and no extra motion labels or new visual-success claims were introduced.

This dataset card does not grant a new license or assert permissions not provided by the dataset owner; confirm applicable usage terms with the owner if needed.