mzxuan/real_world_data_annotated

Real-World Data — Camera-3 Annotations

This dataset provides perception annotations for 1,000 real robot demonstration episodes across five tasks. It is the annotation companion to mzxuan/real_world_data, which contains the original recordings.

Download both datasets for visual robot-learning experiments. This repository does not contain the original RGB, depth, robot state, or action commands. It contains masks, object identities and roles, 2D/3D boxes, annotation-only HDF5 sidecars, and compact visual reviews. The raw HDF5 supplies the observations; the annotation HDF5 supplies the matching labels.

Only camera 3 is annotated. No camera-1/camera-2 labels are implied by this release. All source recordings remain separate and unchanged.

1. What is available now?

Annotation task / archive	Raw task directory	Episodes	Camera-3 frames
put_cup_in_bowl/put_cup_in_bowl.tar	put_cup_in_bowl_amir	200	43,368
put_bowl_on_rack/put_bowl_on_rack.tar	put_bowl_on_rack_amir	200	46,180
stack_two_cubes/stack_two_cubes.tar	stack_two_cubes_amir	200	43,517
put_mug_on_coaster/put_mug_on_coaster.tar	put_mug_on_coaster_amir	200	44,937
place_three_cups_in_bowls/place_three_cups_in_bowls.tar	place_three_cups_in_bowls	200	144,340
Total		1,000	322,342

Each task contains clean/1..100 and d1/1..25, d2/1..25, d3/1..25, d4/1..25. Clean has no deliberately added clutter; d1–d4 indicate one through four added clutter objects. The actual obstacle identities vary by episode. Read that episode's object roster rather than assuming one roster per condition.

There are 322,342 canonical instance masks, 322,342 canonical role masks, and 1,000 annotation sidecars. Counts exclude extra historical prompt/repair previews. Every JSONL family contains one record per frame and configured object, including explicit invisible/invalid records.

Remaining task and loader compatibility

• put_book_in_box: book placement into a wire file basket, pending further annotation review and repair.

The three-cup task is included in this five-task release; the book task is not. Check the pinned release's metadata/episodes.jsonl for exact availability.

One loader can read both sidecar versions. Masks, boxes, object-column order and raw-frame pairing use the same interface. The essential change is role lookup: schema 1 uses fixed objects/roles; schema 2 uses sequence/role_values[t]. For schema 2, objects/roles contains all-obstacle defaults and is NOT the per-frame training label. Never assume instance ID 1 is always the target. Sections 6, 8 and 9 give the exact role rules, fields and shared reading example.

2. Why is this much smaller than the raw dataset?

This release stores labels for one camera, not full multi-camera RGB-D recordings. Masks are compressed label images, not RGB photos. JSONL records store small numeric descriptions. The HDF5 sidecars use compression and do not duplicate raw observations. Only selected frames are rendered for review.

The original FOUR task folders occupy about 11.2 GiB on disk (9.5 GiB of regular-file contents). After excluding the temporary SAM input cache, the included payload is approximately 6.43 GiB: 2.85 GiB of review/prompt images, 1.75 GiB of JSONL, 1.07 GiB of sidecars, 0.66 GiB of PNG masks, and 0.10 GiB of metadata. Some old SAM caches contain converted JPEG copies as well as symlinks; neither is needed to read the annotations. Filesystem allocation is larger because of many small files. Tar headers/padding add overhead; consult metadata/release_manifest.json for exact archive byte counts and hashes. No canonical annotation was dropped to save space. These historical size figures exclude the new three-cup task. The release manifest lists each of the five archives separately with its exact current size.

These are ordinary uncompressed .tar archives. PNG, JPEG, and HDF5 already compress much of the content. Do not use a gzip-only decompressor on these files.

3. Download, verify, and extract

The repository is organized by task, with shared metadata kept separately:

README.md
SHA256SUMS
put_cup_in_bowl/put_cup_in_bowl.tar
put_bowl_on_rack/put_bowl_on_rack.tar
put_mug_on_coaster/put_mug_on_coaster.tar
stack_two_cubes/stack_two_cubes.tar
place_three_cups_in_bowls/place_three_cups_in_bowls.tar
metadata/
  episodes.jsonl
  release_manifest.json
  <task>.files.jsonl
  user_repairs_20260910_promotion.json
  USER_REPAIRS_20260910.md
  build_progress.json
  three_cups_completion_audit_20260912.json
  three_cups_release_validation.json

This organization changes download paths only, not archive contents or extracted episode paths. The initial flat release remains accessible at repository revision 2f8d3f55e8196b70e1d3e45ce0e42190801e9016 if you already pinned it.

Install reader/download dependencies:

python -m pip install huggingface_hub h5py numpy pillow

Download the annotation repository with the official Hugging Face Hub client:

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="mzxuan/real_world_data_annotated",
    repo_type="dataset",
    local_dir="annotation_download",
)

For reproducibility, record the annotation repository's commit ID and pass it as revision= on subsequent downloads. To download only one task, use allow_patterns=["put_cup_in_bowl/*", "README.md", "SHA256SUMS", "metadata/*"]; ignore checksum entries for intentionally undownloaded archives when doing a partial verification.

For a complete download, run:

cd annotation_download
sha256sum -c SHA256SUMS
mkdir -p ../annotations
tar -xf put_cup_in_bowl/put_cup_in_bowl.tar -C ../annotations
tar -xf put_bowl_on_rack/put_bowl_on_rack.tar -C ../annotations
tar -xf stack_two_cubes/stack_two_cubes.tar -C ../annotations
tar -xf put_mug_on_coaster/put_mug_on_coaster.tar -C ../annotations
tar -xf place_three_cups_in_bowls/place_three_cups_in_bowls.tar -C ../annotations

Each archive already contains its task directory. For example, extraction creates annotations/put_cup_in_bowl/clean/2/, not an extra real_world_annotations_mass_v2 directory. Do not strip this task component.

metadata/<task>.files.jsonl supplies a SHA-256 and size for every archived file. SHA256SUMS verifies archives and release metadata; the member manifests allow checking extracted files too. The build verified every archived member against the local accepted source bytes before upload.

This is an archive/HDF5 distribution, not a preconfigured Hugging Face Datasets table or a LeRobot export. Use the file download APIs and your own loader rather than assuming datasets.load_dataset() will construct training samples.

4. Get the matching original recordings

Raw observations are at mzxuan/real_world_data. metadata/release_manifest.json records the raw repository revision inspected while preparing this release. The release does not assert a fresh byte-for-byte comparison of every remote raw tar against the local recordings. Use raw_repo_revisions_by_task for task-specific pins: the original four tasks retain their original raw revision, and the three-cup task uses the corrected one.

For the three-cup task, use corrected raw revision d48ecf0a3cef077e64754191c56ba8d8e77f131a. Its raw paths are place_three_cups_in_bowls/<condition>/place_three_cups_in_bowls_<condition>.tar, without the older tasks' _amir suffix. Earlier versions have incorrect instruction order and retired assignment-policy metadata. Corrected JSON and raw-HDF5 language agree with recorded step order, joined by then; physical pairings, images, states and chunk boundaries were preserved. Do not use the old raw revision in the single-cup example below for this task.

Raw archives are organized by task and condition. Example:

from huggingface_hub import hf_hub_download

raw_archive = hf_hub_download(
    repo_id="mzxuan/real_world_data",
    repo_type="dataset",
    revision="42b9df8f9ae78e806de4a0388d4b3a5da3221624",
    filename="put_cup_in_bowl_amir/clean/put_cup_in_bowl_amir_clean.tar",
    local_dir="raw_download",
)
print(raw_archive)

Inspect raw tar members before extraction (tar -tf <raw_archive>). Historical archives may have different leading directory components; do not assume the annotation extraction layout applies to raw archives. Organize the extracted raw episode directories so your loader can locate the recorded episodeN.hdf5, state.csv, meta.json, and intrinsics.json for each manifest entry.

The authoritative episode pairing is metadata/episodes.jsonl. Each line records the annotation path, sidecar path, raw task/condition/episode, raw archive path, frame count, object roster, source metadata hashes, and contact-sheet paths. Do not join using the bare episode number: clean/1 and d1/1 are different demonstrations, and episode numbers repeat across tasks.

5. Per-episode directory layout

<task>/<condition>/<episode>/
  manifest.json
  audit.json
  validation.json
  sidecar_validation.json
  episodeN.annotations.hdf5
  sequence.json (three-cup task only)
  camera3/
    instances/*.png
    roles/*.png
    boxes2d.jsonl
    boxes3d.jsonl
    boxes2d_amodal.jsonl
    review_samples.json
    review_samples/2d/*.jpg
    review_samples/3d/*.jpg
    contact_sheet.jpg
    contact_sheet3d.jpg
    diagnostics3d/*.jpg
  geometry3d/
    object_dimensions.json
    calibration_report.json
    validation3d.json
    qc3d.json

All existing regular task files are retained, including available config.json, prompts.json, repair receipts, and .work prompt/repair previews. Some historical episodes reference configs/prompts in the original preprocessing checkout instead of storing a local copy. Reading the labels requires neither SAM nor these files; do not claim the archive alone can regenerate every historical annotation.

The only excluded subtree is **/.work/sam2_frames/**: these are temporary absolute symlinks or converted JPEG copies used to feed raw images to SAM, not independent annotation data. They are not dereferenced or uploaded. No raw RGB is silently pulled into the archives.

Training and final QA must read the canonical camera3/ files, not intermediate .work results. Intermediate previews may predate a repair. Absolute filesystem paths inside historical JSON/HDF5 provenance describe the build machine and are not portable download paths; use metadata/episodes.jsonl and the relative layout above.

6. Masks, identities, roles, and 2D boxes

Instance PNGs contain integer IDs (uint16), with 0 reserved for background. Load them without converting to RGB or an 8-bit image. IDs are persistent within an episode. IDs 1 and 2 are task-relative, not universal semantic classes.

Instance ID	Meaning in the original four tasks (schema 1)
1	Moving target: blue cup, cyan bowl, blue mug, or manipulated cube_a
2	Destination: white bowl, full dish rack, coaster, or stationary cube_b
3	Red apple
4	Stapler
5	Black mouse
6	Paper-towel roll
7	Tea box
8	Teal water bottle
9	Pink plastic cup
10	Black coffee cup
11	Table-tennis paddle

Only the IDs in the episode's roster are expected. Read objects/ids and objects/names from HDF5 or manifest.json; never assume IDs are contiguous. Some names are historical catalog labels rather than literal color descriptions. The coaster can appear under historical coaster or patterned_coaster names; its episode-local ID and destination role are authoritative.

Role PNG values are 0 background, 1 target, 2 destination, 3 obstacle in BOTH schemas. Instance IDs identify physical objects; role values describe their current function. These are separate label spaces even when their numbers match.

Three-cup physical IDs and changing roles (schema 2)

Instance ID	Physical object
1	cup_blue
2	cup_pink
3	cup_yellow
4	bowl_blue
5	bowl_pink
6	bowl_yellow
7	apple
8	rubik_cube
9	mouse
10	carrot

IDs are task-scoped and never renumbered when the active pair changes. Missing clutter IDs are omitted: d1/20, for example, has IDs [1,2,3,4,5,6,10]. Clean tracks six objects; dN tracks six plus N added clutter objects. During an active chunk, all objects outside its target/destination pair are obstacles, including future pairs and pairs already placed. Clean therefore has four obstacle-role objects while a pair is active, despite having no added clutter.

• The first pair is active from frame 0, including initial calibration.
• The current pair stays active through release, settling and the following calibration hold. Roles switch at the next recorded chunk's approach boundary, not immediately when the cup touches the bowl or the gripper opens.
• Final idle frames have no active pair: all objects are obstacles. A loader must handle zero targets/destinations without inventing a pair.
• Role masks and all three box JSONL families already contain resolved per-frame roles. No instance-mask remapping or ID swapping is needed in the loader.

Verified place_three_cups_in_bowls/clean/1 example (zero-based frames):

Frame	Target	Destination	Recorded chunk / phase
0	pink cup, ID 2	yellow bowl, ID 6	-1 / hold_calibration
231	pink cup, ID 2	yellow bowl, ID 6	0 / hold_calibration
232	yellow cup, ID 3	blue bowl, ID 4	1 / approach
709	none	none	-1 / idle

chunk_index=-1 alone does not mean all-obstacle: frame 0 intentionally uses the first pair. Use resolved roles, not a reconstruction from chunk index.

Masks are modal: they label visible object material, not hidden surfaces. The bowl/rack/coaster mask excludes the placed target; rack gaps remain background. The dish-rack destination includes its small flat placement side. For cubes, ID 1 follows the manipulated cube and ID 2 stays on the base cube after stacking.

boxes2d.jsonl records frame index, filename, timestamp, camera, instance ID, name, role, visibility, area, and bbox2d_modal_xyxy. Coordinates are [xmin, ymin, xmax, ymax] in the original 640 x 480 image, with inclusive maximum coordinates. Therefore width is xmax - xmin + 1. An invisible object's JSON box is null, visibility is false, and area is zero. HDF5 represents the missing modal box as [-1, -1, -1, -1].

7. 3D geometry and validity

3D labels are estimated full oriented boxes produced by table_constrained_full_obb_v2: RGB-D/mask evidence, table-plane fitting, reviewed dimensions, and recorded geometry policies. They are pseudo-ground-truth estimates, not motion-capture measurements or certified collision geometry.

The coordinate frame is the OpenCV camera-3 frame, in meters:

• +X right, +Y down, +Z forward.
• The 12D vector is center XYZ (3), full length/width/height (3), rotation-6D (6).
• Rotation-6D is rotation-matrix column 0 followed by column 1.
• Sizes are full extents, not half extents; they are not image width/height.

For a valid rotation vector r6, recover columns with r1 = r6[:3], r2 = r6[3:], and r3 = cross(r1, r2), then stack as matrix columns. Preserve the supplied conventions when augmenting images or changing coordinate frames. These annotations were not transformed into robot-base coordinates. A calibration file present elsewhere is not automatically applicable to these labels.

boxes3d.jsonl includes validity, reason, 12D box, camera-frame corners, table plane, pose provenance, and quality flags. boxes2d_amodal.jsonl is the projection of the full 3D box, not a human-drawn hidden silhouette. It can extend outside the image and has its own validity flag.

Stationary destination/obstacle poses are generally frozen from robust clear measurements and carried through temporary occlusion. A valid frozen 3D box may coexist with an invisible modal mask: this is intentional. Never equate 3D validity with 2D visibility. Moving targets remain dynamic; insufficient evidence is represented explicitly rather than fabricated. Do not fill missing labels with zeros or silently train on NaNs.

For the three-cup task, bowls and added clutter have frozen stationary poses; all three cups have dynamic poses regardless of current target/obstacle role. An obstacle role does not imply a stationary physical object. Dimensions and table-constrained orientation remain estimates, especially for tilted cups; changing the sidecar schema does not improve geometric certainty.

Important limitations retained in the files:

• Paddle orientation remains review_pending/low-confidence. Some edge-on poses use explicitly flagged table-support/projective inference. Filter or downweight these 3D records for tasks requiring accurate orientation.
• In cube d4/17, the paddle falls; frames 35–53 are explicitly invalid for unreliable falling pose. The earlier and later stable poses differ.
• In cup d3/18, the towel is displaced and is not forced into one static pose.
• User acceptance is based on contact sheets and targeted visual checks, not an exhaustive independent pixel-by-pixel certification of every frame/object.
• Historical review-pending fields remain where appropriate; successful structural checks do not turn uncertain geometry into exact ground truth.

8. Annotation HDF5 schema

Root format is rwprep_annotation_sidecar. Read root attribute schema_version: 1 for the original four tasks, 2 for the three-cup task. Existing schema-1 files are not migrated or regenerated. Let T be the frame count, O the object count, and H x W = 480 x 640. These fields are shared:

Dataset/group	Meaning / shape
frames/indices	Contiguous zero-based annotation frame index, T
frames/state_indices	Source CSV frame indices, T
frames/timestamps	Source recorded image/state timestamps, T
objects/ids, names, roles	Ordered object columns, O; roles are active labels ONLY for schema 1
objects/dimensions_lwh_m	Full metric dimensions, O x 3
objects/dimensions_status, orientation_status, geometry_confidence	Geometry status per object
objects/review_flags_json, metadata_json, source_json	Complete dimension metadata/provenance
cameras/camera3/source_rgb_filenames, source_depth_filenames	Original source basenames, T
cameras/camera3/intrinsics	Camera matrix, distortion, depth scale, original intrinsics JSON
cameras/camera3/instances	uint16 label masks, T x H x W
cameras/camera3/roles	uint8 role masks, T x H x W
cameras/camera3/boxes2d/modal_xyxy	int32 inclusive boxes, T x O x 4
cameras/camera3/boxes2d/visible, area_pixels	T x O visibility/area
cameras/camera3/boxes3d/center_size_rot6d	float64 boxes, T x O x 12
cameras/camera3/boxes3d/corners_camera_xyz_m	T x O x 8 x 3 corners
cameras/camera3/boxes3d/valid, invalid_reason, quality_flags_json	T x O validity and quality
cameras/camera3/boxes3d/pose_*	Pose source, observed/carried status, measurement-frame provenance
cameras/camera3/boxes2d_amodal/xyxy, valid, invalid_reason	Projected float boxes and validity
cameras/camera3/table_planes/*	Per-frame plane normals, offsets, support, validity
provenance/manifest_json, package_json	Historical manifests, build paths, hashes

Missing numeric 3D/amodal data use NaNs; consult validity before consuming them. Object columns follow objects/ids order, not object_id - 1. HDF5 strings are UTF-8; with h5py use .asstr() when decoded strings are needed. Fields ending in _json contain JSON strings, not ordinary category names.

PNG/JSONL labels are canonical; sidecars are validated, compressed mirrors for convenient loading. All 800 sidecars were freshly round-trip checked against their canonical labels when packaging the original release. The new task's 200 sidecars also passed fresh release round trips. The previous 800 sidecars and their archives are retained byte-for-byte, not regenerated or newly re-certified.

Schema-2 sequence extension

Root role_mode is state_sequence. Per-frame object roles use 1 target, 2 destination, 3 obstacle; background 0 appears in pixel masks, not object columns.

Dataset	Meaning / shape
sequence/role_values	uint8 per-frame roles, T x O; columns follow objects/ids
sequence/active_target_instance_id	Numeric physical target ID, T; 0 when idle
sequence/active_destination_instance_id	Numeric physical destination ID, T; 0 when idle
sequence/active_target_id, active_destination_id	Resolved physical names, T; empty strings when idle
sequence/recorded_active_target_id, recorded_active_destination_id	Original raw active-name strings, T; preserve empty initial calibration IDs
sequence/chunk_index	Unmodified recorded indices 0, 1, 2, or -1, T
sequence/phase	Unmodified recorded phase strings, T
sequence/role_source	Why the resolved pair was chosen, T
sequence/source_json	Scalar UTF-8 JSON, same payload as canonical sequence.json

role_source is first_chunk_pair_during_initial_calibration during the initial override, recorded_active_pair during active chunks, or recorded_idle. The sequence group declares initial_role_policy=first_chunk_pair_from_frame_zero, chunk_index_semantics=recorded_unmodified and object_column_order=objects/ids. The raw CSV/HDF5 are not rewritten to introduce the frame-zero role override.

Decode sequence/source_json with json.loads(...asstr()[()]). Its source field contains corrected collection metadata: language_instruction, ordered steps, rosters and recorded events. Its frames field contains resolved context for every annotation frame. This JSON payload's own schema_version is separate from the HDF5 root schema; use the HDF5 root attribute for the loader branch.

Use frame indices and frames/timestamps for alignment. Recorded step event timestamps refer to the preceding image in this corpus, while integer event boundaries agree with per-frame context. Do not shift roles one frame earlier using a nearest-timestamp lookup. Preserve event timestamps as provenance.

9. Minimal aligned reading example

After extracting matching raw data, set raw_root to the directory holding the original task directories. No original preprocessing checkout, SAM checkpoint, or GPU is needed to read the annotations.

Use this role helper for both schemas. Unknown versions fail explicitly; the schema-2 branch never falls back to the all-obstacle object defaults.

import numpy as np

def roles_for_frame(ann, t):
    version = int(ann.attrs["schema_version"])
    if not 0 <= t < len(ann["frames/indices"]):
        raise IndexError(t)
    if version == 1:
        values = {"target": 1, "destination": 2, "obstacle": 3}
        roles = np.asarray([values[name] for name in ann["objects/roles"].asstr()[...]], dtype=np.uint8)
    elif version == 2:
        roles = ann["sequence/role_values"][t]
    else:
        raise ValueError(f"Unsupported annotation schema: {version}")
    if roles.shape != ann["objects/ids"].shape or not np.isin(roles, [1, 2, 3]).all():
        raise ValueError("Invalid object roles or column count")
    targets = np.count_nonzero(roles == 1)
    destinations = np.count_nonzero(roles == 2)
    if targets != destinations or targets > 1:
        raise ValueError("Expected one active pair or no active pair")
    return roles

Then read an aligned observation and its current target. The example selects an single-cup episode. To use the three-cup task, change entry to place_three_cups_in_bowls/clean/1 and try t=231 and t=232 to observe the role switch; no other loader changes are needed.

import json
from pathlib import Path

import h5py
import numpy as np

annotation_root = Path("annotations")
raw_root = Path("raw")
rows = [json.loads(line) for line in Path("annotation_download/metadata/episodes.jsonl").read_text().splitlines()]
entry = next(r for r in rows if r["episode"] == "put_cup_in_bowl/clean/2")
raw_path = raw_root / entry["source_episode"] / entry["source_hdf5_filename"]
annotation_path = annotation_root / entry["sidecar_path"]

with h5py.File(raw_path, "r") as raw, h5py.File(annotation_path, "r") as ann:
    assert np.array_equal(raw["timestamps"][...], ann["frames/timestamps"][...])
    assert len(raw["timestamps"]) == entry["frames"]
    t = 0
    source_index = int(ann["frames/state_indices"][t])
    assert source_index == t
    camera = ann["cameras/camera3"]
    rgb = raw["observations/images/camera3"][source_index]
    tcp_position = raw["observations/tcp_pos"][source_index]
    tcp_quaternion = raw["observations/tcp_quat"][source_index]
    gripper = raw["observations/gripper_pos"][source_index]
    instance_mask = camera["instances"][t]
    object_ids = ann["objects/ids"][...]
    role_values = roles_for_frame(ann, t)
    target_columns = np.flatnonzero(role_values == 1)
    destination_columns = np.flatnonzero(role_values == 2)
    obstacle_columns = np.flatnonzero(role_values == 3)
    target = None
    if target_columns.size:
        column = int(target_columns[0])
        target_id = int(object_ids[column])
        visible = bool(camera["boxes2d/visible"][t, column])
        valid3d = bool(camera["boxes3d/valid"][t, column])
        target = {
            "id": target_id,
            "mask": instance_mask == target_id,
            "visible": visible,
            "box2d": camera["boxes2d/modal_xyxy"][t, column] if visible else None,
            "valid3d": valid3d,
            "box3d": camera["boxes3d/center_size_rot6d"][t, column] if valid3d else None,
            "flags": json.loads(camera["boxes3d/quality_flags_json"].asstr()[t, column]),
        }

Read destination/obstacle records with their corresponding columns in the same way. An object can remain the target even when its visible mask is empty. Final idle frames produce target=None; excluding these from an action loss is a training-policy decision, not permission to fabricate an active target.

For sequence context, inside an open schema-2 sidecar:

chunk = int(ann["sequence/chunk_index"][t])
phase = ann["sequence/phase"].asstr()[t]
target_name = ann["sequence/active_target_id"].asstr()[t]
destination_name = ann["sequence/active_destination_id"].asstr()[t]
sequence = json.loads(ann["sequence/source_json"].asstr()[()])
instruction = sequence["source"]["language_instruction"]
steps = sequence["source"]["steps"]

For these recordings, source row indices are contiguous. If alignment assertions fail on your downloaded raw files, stop and resolve the version/path mismatch; do not silently trim, sort by unrelated filenames, or pair nearest timestamps. metadata/episodes.jsonl includes source CSV/intrinsics/meta hashes for additional checks.

Use state.csv order, not every PNG in a raw directory. In particular, cup d3/1..8 contain older unreferenced captures that must be ignored. The matching HDF5 and sidecar contain the intended state-aligned take.

10. Actions, instructions, splits, and normalization

This release is ready to serve as observations plus perception labels; it is not a finished action-supervised training recipe. Raw recordings contain TCP pose, joint state, and gripper state, but no separately named action dataset has been established by this annotation release.

Your loader may define future observed poses, pose changes, or other trajectory targets. Document the prediction horizon, reference frame, quaternion convention, gripper interpretation, and terminal-frame handling. Observed states are not automatically the robot's original commanded actions. Do not subtract quaternion components as though they were Cartesian rotation deltas.

The release does not prescribe train/validation/test splits or normalization statistics. Split by whole episode, keep all frames from a demonstration in one split, then compute normalization using only training episodes. Decide whether to hold out layouts/conditions for generalization evaluation. Add language instructions explicitly in the loader; task names and object metadata are supplied, but a finalized per-sample instruction dataset is not included. The three-cup task supplies its corrected episode instruction and ordered step metadata in sequence/source_json; decide explicitly whether training uses the complete instruction or a chunk-specific instruction. Do not reconstruct instructions from color order or infer retired forced/unrestricted assignment-policy labels. Keep all three chunks of an episode in the same train/validation/test split.

Start with a small batch: verify image/mask alignment, object-column mapping, box conventions, invalid-record filtering, and action-target alignment before large-scale training. Rendered contact sheets are QA tools, not model observations. Keep HDF5 handles worker-local if using multiprocessing dataloaders.

11. Review, provenance, and release contents

Open camera3/contact_sheet.jpg for masks plus modal 2D and camera3/contact_sheet3d.jpg for projected 3D. Full-resolution sampled overlays are in review_samples/; RGB/point-cloud diagnostics are in diagnostics3d/. Review sampling is compact (up to 16 frames per camera, normally eight uniform frames plus selected events). There are no canonical full-frame overlay videos, MP4 reviewers, or HTML reviewers.

This release includes the 63 user-approved replacements promoted on 2026-09-10: 17 cup, 18 mug, and 28 cube episodes. They already replace the corresponding canonical folders; do not apply another repair overlay after extraction. metadata/user_repairs_20260910_promotion.json and the accompanying note retain the promotion provenance. Old backup paths named there are historical, not additional files you need to download.

Historic timing CSVs/wave atlases outside the task directories are not used as authoritative current QA; per-episode canonical contact sheets include the accepted repairs. Rejected template-stamped references, superseded backups, raw datasets, environment credentials, and model checkpoints are not part of this release.

The book task will be added after review and repair. Pin a repository revision for reproducibility. The original organized four-task release is preserved at 1fbd6114ad48868c714e3bac9a56426ea04dbe9e; this addition does not change its four archive payloads. Task-six completion provenance and fresh release checks are in metadata/three_cups_completion_audit_20260912.json and metadata/three_cups_release_validation.json.

12. Access and licensing

The repository is public for download. Public access is not itself a license grant. No license is asserted by this annotation card; confirm permitted use and redistribution with the dataset owners and check the source dataset's terms. Do not assume a permissive license from the availability of the files.